1# Copyright (c) 2004-2006 The Regents of The University of Michigan
2# Copyright (c) 2010-2011 Advanced Micro Devices, Inc.
3# All rights reserved.
4#
5# Redistribution and use in source and binary forms, with or without
6# modification, are permitted provided that the following conditions are
7# met: redistributions of source code must retain the above copyright
8# notice, this list of conditions and the following disclaimer;
9# redistributions in binary form must reproduce the above copyright
10# notice, this list of conditions and the following disclaimer in the
11# documentation and/or other materials provided with the distribution;
12# neither the name of the copyright holders nor the names of its
13# contributors may be used to endorse or promote products derived from
14# this software without specific prior written permission.
15#
16# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
18# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
19# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
20# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27#
28# Authors: Steve Reinhardt
29# Nathan Binkert
30# Gabe Black
31
32#####################################################################
33#
34# Parameter description classes
35#
36# The _params dictionary in each class maps parameter names to either
37# a Param or a VectorParam object. These objects contain the
38# parameter description string, the parameter type, and the default
39# value (if any). The convert() method on these objects is used to
40# force whatever value is assigned to the parameter to the appropriate
41# type.
42#
43# Note that the default values are loaded into the class's attribute
44# space when the parameter dictionary is initialized (in
45# MetaSimObject._new_param()); after that point they aren't used.
46#
47#####################################################################
48
49import copy
50import datetime
51import re
52import sys
53import time
54import math
55
56import proxy
57import ticks
58from util import *
59
60def isSimObject(*args, **kwargs):
61 return SimObject.isSimObject(*args, **kwargs)
62
63def isSimObjectSequence(*args, **kwargs):
64 return SimObject.isSimObjectSequence(*args, **kwargs)
65
66def isSimObjectClass(*args, **kwargs):
67 return SimObject.isSimObjectClass(*args, **kwargs)
68
69allParams = {}
70
71class MetaParamValue(type):
72 def __new__(mcls, name, bases, dct):
73 cls = super(MetaParamValue, mcls).__new__(mcls, name, bases, dct)
74 assert name not in allParams
75 allParams[name] = cls
76 return cls
77
78
79# Dummy base class to identify types that are legitimate for SimObject
80# parameters.
81class ParamValue(object):
82 __metaclass__ = MetaParamValue
83
84 @classmethod
85 def cxx_predecls(cls, code):
86 pass
87
88 @classmethod
89 def swig_predecls(cls, code):
90 pass
91
92 # default for printing to .ini file is regular string conversion.
93 # will be overridden in some cases
94 def ini_str(self):
95 return str(self)
96
97 # allows us to blithely call unproxy() on things without checking
98 # if they're really proxies or not
99 def unproxy(self, base):
100 return self
101
102# Regular parameter description.
103class ParamDesc(object):
104 file_ext = 'ptype'
105
106 def __init__(self, ptype_str, ptype, *args, **kwargs):
107 self.ptype_str = ptype_str
108 # remember ptype only if it is provided
109 if ptype != None:
110 self.ptype = ptype
111
112 if args:
113 if len(args) == 1:
114 self.desc = args[0]
115 elif len(args) == 2:
116 self.default = args[0]
117 self.desc = args[1]
118 else:
119 raise TypeError, 'too many arguments'
120
121 if kwargs.has_key('desc'):
122 assert(not hasattr(self, 'desc'))
123 self.desc = kwargs['desc']
124 del kwargs['desc']
125
126 if kwargs.has_key('default'):
127 assert(not hasattr(self, 'default'))
128 self.default = kwargs['default']
129 del kwargs['default']
130
131 if kwargs:
132 raise TypeError, 'extra unknown kwargs %s' % kwargs
133
134 if not hasattr(self, 'desc'):
135 raise TypeError, 'desc attribute missing'
136
137 def __getattr__(self, attr):
138 if attr == 'ptype':
139 ptype = SimObject.allClasses[self.ptype_str]
140 assert isSimObjectClass(ptype)
141 self.ptype = ptype
142 return ptype
143
144 raise AttributeError, "'%s' object has no attribute '%s'" % \
145 (type(self).__name__, attr)
146
147 def convert(self, value):
148 if isinstance(value, proxy.BaseProxy):
149 value.set_param_desc(self)
150 return value
151 if not hasattr(self, 'ptype') and isNullPointer(value):
152 # deferred evaluation of SimObject; continue to defer if
153 # we're just assigning a null pointer
154 return value
155 if isinstance(value, self.ptype):
156 return value
157 if isNullPointer(value) and isSimObjectClass(self.ptype):
158 return value
159 return self.ptype(value)
160
161 def cxx_predecls(self, code):
162 self.ptype.cxx_predecls(code)
163
164 def swig_predecls(self, code):
165 self.ptype.swig_predecls(code)
166
167 def cxx_decl(self, code):
168 code('${{self.ptype.cxx_type}} ${{self.name}};')
169
170# Vector-valued parameter description. Just like ParamDesc, except
171# that the value is a vector (list) of the specified type instead of a
172# single value.
173
174class VectorParamValue(list):
175 __metaclass__ = MetaParamValue
176 def __setattr__(self, attr, value):
177 raise AttributeError, \
178 "Not allowed to set %s on '%s'" % (attr, type(self).__name__)
179
180 def ini_str(self):
181 return ' '.join([v.ini_str() for v in self])
182
183 def getValue(self):
184 return [ v.getValue() for v in self ]
185
186 def unproxy(self, base):
187 if len(self) == 1 and isinstance(self[0], proxy.AllProxy):
188 return self[0].unproxy(base)
189 else:
190 return [v.unproxy(base) for v in self]
191
192class SimObjectVector(VectorParamValue):
193 # support clone operation
194 def __call__(self, **kwargs):
195 return SimObjectVector([v(**kwargs) for v in self])
196
197 def clear_parent(self, old_parent):
198 for v in self:
199 v.clear_parent(old_parent)
200
201 def set_parent(self, parent, name):
202 if len(self) == 1:
203 self[0].set_parent(parent, name)
204 else:
205 width = int(math.ceil(math.log(len(self))/math.log(10)))
206 for i,v in enumerate(self):
207 v.set_parent(parent, "%s%0*d" % (name, width, i))
208
209 def has_parent(self):
210 return reduce(lambda x,y: x and y, [v.has_parent() for v in self])
211
212 # return 'cpu0 cpu1' etc. for print_ini()
213 def get_name(self):
214 return ' '.join([v._name for v in self])
215
216 # By iterating through the constituent members of the vector here
217 # we can nicely handle iterating over all a SimObject's children
218 # without having to provide lots of special functions on
219 # SimObjectVector directly.
220 def descendants(self):
221 for v in self:
222 for obj in v.descendants():
223 yield obj
224
225class VectorParamDesc(ParamDesc):
226 file_ext = 'vptype'
227
228 # Convert assigned value to appropriate type. If the RHS is not a
229 # list or tuple, it generates a single-element list.
230 def convert(self, value):
231 if isinstance(value, (list, tuple)):
232 # list: coerce each element into new list
233 tmp_list = [ ParamDesc.convert(self, v) for v in value ]
234 else:
235 # singleton: coerce to a single-element list
236 tmp_list = [ ParamDesc.convert(self, value) ]
237
238 if isSimObjectSequence(tmp_list):
239 return SimObjectVector(tmp_list)
240 else:
241 return VectorParamValue(tmp_list)
242
243 def swig_predecls(self, code):
244 code('%import "vptype_${{self.ptype_str}}.i"')
245
246 def swig_decl(self, code):
247 code('%{')
248 self.ptype.cxx_predecls(code)
249 code('%}')
250 code()
251 self.ptype.swig_predecls(code)
252 code()
253 code('%include "std_vector.i"')
254 code()
255
256 ptype = self.ptype_str
257 cxx_type = self.ptype.cxx_type
258
259 code('''\
260%typemap(in) std::vector< $cxx_type >::value_type {
261 if (SWIG_ConvertPtr($$input, (void **)&$$1, $$1_descriptor, 0) == -1) {
262 if (SWIG_ConvertPtr($$input, (void **)&$$1,
263 $$descriptor($cxx_type), 0) == -1) {
264 return NULL;
265 }
266 }
267}
268
269%typemap(in) std::vector< $cxx_type >::value_type * {
270 if (SWIG_ConvertPtr($$input, (void **)&$$1, $$1_descriptor, 0) == -1) {
271 if (SWIG_ConvertPtr($$input, (void **)&$$1,
272 $$descriptor($cxx_type *), 0) == -1) {
273 return NULL;
274 }
275 }
276}
277''')
278
279 code('%template(vector_$ptype) std::vector< $cxx_type >;')
280
281 def cxx_predecls(self, code):
282 code('#include <vector>')
283 self.ptype.cxx_predecls(code)
284
285 def cxx_decl(self, code):
286 code('std::vector< ${{self.ptype.cxx_type}} > ${{self.name}};')
287
288class ParamFactory(object):
289 def __init__(self, param_desc_class, ptype_str = None):
290 self.param_desc_class = param_desc_class
291 self.ptype_str = ptype_str
292
293 def __getattr__(self, attr):
294 if self.ptype_str:
295 attr = self.ptype_str + '.' + attr
296 return ParamFactory(self.param_desc_class, attr)
297
298 # E.g., Param.Int(5, "number of widgets")
299 def __call__(self, *args, **kwargs):
300 ptype = None
301 try:
302 ptype = allParams[self.ptype_str]
303 except KeyError:
304 # if name isn't defined yet, assume it's a SimObject, and
305 # try to resolve it later
306 pass
307 return self.param_desc_class(self.ptype_str, ptype, *args, **kwargs)
308
309Param = ParamFactory(ParamDesc)
310VectorParam = ParamFactory(VectorParamDesc)
311
312#####################################################################
313#
314# Parameter Types
315#
316# Though native Python types could be used to specify parameter types
317# (the 'ptype' field of the Param and VectorParam classes), it's more
318# flexible to define our own set of types. This gives us more control
319# over how Python expressions are converted to values (via the
320# __init__() constructor) and how these values are printed out (via
321# the __str__() conversion method).
322#
323#####################################################################
324
325# String-valued parameter. Just mixin the ParamValue class with the
326# built-in str class.
327class String(ParamValue,str):
328 cxx_type = 'std::string'
329
330 @classmethod
331 def cxx_predecls(self, code):
332 code('#include <string>')
333
334 @classmethod
335 def swig_predecls(cls, code):
336 code('%include "std_string.i"')
337
338 def getValue(self):
339 return self
340
341# superclass for "numeric" parameter values, to emulate math
342# operations in a type-safe way. e.g., a Latency times an int returns
343# a new Latency object.
344class NumericParamValue(ParamValue):
345 def __str__(self):
346 return str(self.value)
347
348 def __float__(self):
349 return float(self.value)
350
351 def __long__(self):
352 return long(self.value)
353
354 def __int__(self):
355 return int(self.value)
356
357 # hook for bounds checking
358 def _check(self):
359 return
360
361 def __mul__(self, other):
362 newobj = self.__class__(self)
363 newobj.value *= other
364 newobj._check()
365 return newobj
366
367 __rmul__ = __mul__
368
369 def __div__(self, other):
370 newobj = self.__class__(self)
371 newobj.value /= other
372 newobj._check()
373 return newobj
374
375 def __sub__(self, other):
376 newobj = self.__class__(self)
377 newobj.value -= other
378 newobj._check()
379 return newobj
380
381# Metaclass for bounds-checked integer parameters. See CheckedInt.
382class CheckedIntType(MetaParamValue):
383 def __init__(cls, name, bases, dict):
384 super(CheckedIntType, cls).__init__(name, bases, dict)
385
386 # CheckedInt is an abstract base class, so we actually don't
387 # want to do any processing on it... the rest of this code is
388 # just for classes that derive from CheckedInt.
389 if name == 'CheckedInt':
390 return
391
392 if not (hasattr(cls, 'min') and hasattr(cls, 'max')):
393 if not (hasattr(cls, 'size') and hasattr(cls, 'unsigned')):
394 panic("CheckedInt subclass %s must define either\n" \
395 " 'min' and 'max' or 'size' and 'unsigned'\n",
396 name);
397 if cls.unsigned:
398 cls.min = 0
399 cls.max = 2 ** cls.size - 1
400 else:
401 cls.min = -(2 ** (cls.size - 1))
402 cls.max = (2 ** (cls.size - 1)) - 1
403
404# Abstract superclass for bounds-checked integer parameters. This
405# class is subclassed to generate parameter classes with specific
406# bounds. Initialization of the min and max bounds is done in the
407# metaclass CheckedIntType.__init__.
408class CheckedInt(NumericParamValue):
409 __metaclass__ = CheckedIntType
410
411 def _check(self):
412 if not self.min <= self.value <= self.max:
413 raise TypeError, 'Integer param out of bounds %d < %d < %d' % \
414 (self.min, self.value, self.max)
415
416 def __init__(self, value):
417 if isinstance(value, str):
418 self.value = convert.toInteger(value)
419 elif isinstance(value, (int, long, float, NumericParamValue)):
420 self.value = long(value)
421 else:
422 raise TypeError, "Can't convert object of type %s to CheckedInt" \
423 % type(value).__name__
424 self._check()
425
426 @classmethod
427 def cxx_predecls(cls, code):
428 # most derived types require this, so we just do it here once
429 code('#include "base/types.hh"')
430
431 @classmethod
432 def swig_predecls(cls, code):
433 # most derived types require this, so we just do it here once
434 code('%import "stdint.i"')
435 code('%import "base/types.hh"')
436
437 def getValue(self):
438 return long(self.value)
439
440class Int(CheckedInt): cxx_type = 'int'; size = 32; unsigned = False
441class Unsigned(CheckedInt): cxx_type = 'unsigned'; size = 32; unsigned = True
442
443class Int8(CheckedInt): cxx_type = 'int8_t'; size = 8; unsigned = False
444class UInt8(CheckedInt): cxx_type = 'uint8_t'; size = 8; unsigned = True
445class Int16(CheckedInt): cxx_type = 'int16_t'; size = 16; unsigned = False
446class UInt16(CheckedInt): cxx_type = 'uint16_t'; size = 16; unsigned = True
447class Int32(CheckedInt): cxx_type = 'int32_t'; size = 32; unsigned = False
448class UInt32(CheckedInt): cxx_type = 'uint32_t'; size = 32; unsigned = True
449class Int64(CheckedInt): cxx_type = 'int64_t'; size = 64; unsigned = False
450class UInt64(CheckedInt): cxx_type = 'uint64_t'; size = 64; unsigned = True
451
452class Counter(CheckedInt): cxx_type = 'Counter'; size = 64; unsigned = True
453class Tick(CheckedInt): cxx_type = 'Tick'; size = 64; unsigned = True
454class TcpPort(CheckedInt): cxx_type = 'uint16_t'; size = 16; unsigned = True
455class UdpPort(CheckedInt): cxx_type = 'uint16_t'; size = 16; unsigned = True
456
457class Percent(CheckedInt): cxx_type = 'int'; min = 0; max = 100
458
459class Float(ParamValue, float):
460 cxx_type = 'double'
461
462 def __init__(self, value):
463 if isinstance(value, (int, long, float, NumericParamValue, Float)):
464 self.value = float(value)
465 else:
466 raise TypeError, "Can't convert object of type %s to Float" \
467 % type(value).__name__
468
469 def getValue(self):
470 return float(self.value)
471
472class MemorySize(CheckedInt):
473 cxx_type = 'uint64_t'
474 size = 64
475 unsigned = True
476 def __init__(self, value):
477 if isinstance(value, MemorySize):
478 self.value = value.value
479 else:
480 self.value = convert.toMemorySize(value)
481 self._check()
482
483class MemorySize32(CheckedInt):
484 cxx_type = 'uint32_t'
485 size = 32
486 unsigned = True
487 def __init__(self, value):
488 if isinstance(value, MemorySize):
489 self.value = value.value
490 else:
491 self.value = convert.toMemorySize(value)
492 self._check()
493
494class Addr(CheckedInt):
495 cxx_type = 'Addr'
496 size = 64
497 unsigned = True
498 def __init__(self, value):
499 if isinstance(value, Addr):
500 self.value = value.value
501 else:
502 try:
503 self.value = convert.toMemorySize(value)
504 except TypeError:
505 self.value = long(value)
506 self._check()
507 def __add__(self, other):
508 if isinstance(other, Addr):
509 return self.value + other.value
510 else:
511 return self.value + other
512
513
514class MetaRange(MetaParamValue):
515 def __init__(cls, name, bases, dict):
516 super(MetaRange, cls).__init__(name, bases, dict)
517 if name == 'Range':
518 return
519 cls.cxx_type = 'Range< %s >' % cls.type.cxx_type
520
521class Range(ParamValue):
522 __metaclass__ = MetaRange
523 type = Int # default; can be overridden in subclasses
524 def __init__(self, *args, **kwargs):
525 def handle_kwargs(self, kwargs):
526 if 'end' in kwargs:
527 self.second = self.type(kwargs.pop('end'))
528 elif 'size' in kwargs:
529 self.second = self.first + self.type(kwargs.pop('size')) - 1
530 else:
531 raise TypeError, "Either end or size must be specified"
532
533 if len(args) == 0:
534 self.first = self.type(kwargs.pop('start'))
535 handle_kwargs(self, kwargs)
536
537 elif len(args) == 1:
538 if kwargs:
539 self.first = self.type(args[0])
540 handle_kwargs(self, kwargs)
541 elif isinstance(args[0], Range):
542 self.first = self.type(args[0].first)
543 self.second = self.type(args[0].second)
544 elif isinstance(args[0], (list, tuple)):
545 self.first = self.type(args[0][0])
546 self.second = self.type(args[0][1])
547 else:
548 self.first = self.type(0)
549 self.second = self.type(args[0]) - 1
550
551 elif len(args) == 2:
552 self.first = self.type(args[0])
553 self.second = self.type(args[1])
554 else:
555 raise TypeError, "Too many arguments specified"
556
557 if kwargs:
558 raise TypeError, "too many keywords: %s" % kwargs.keys()
559
560 def __str__(self):
561 return '%s:%s' % (self.first, self.second)
562
563 @classmethod
564 def cxx_predecls(cls, code):
565 cls.type.cxx_predecls(code)
566 code('#include "base/range.hh"')
567
568 @classmethod
569 def swig_predecls(cls, code):
570 cls.type.swig_predecls(code)
571 code('%import "python/swig/range.i"')
572
573class AddrRange(Range):
574 type = Addr
575
576 def getValue(self):
577 from m5.internal.range import AddrRange
578
579 value = AddrRange()
580 value.start = long(self.first)
581 value.end = long(self.second)
582 return value
583
584class TickRange(Range):
585 type = Tick
586
587 def getValue(self):
588 from m5.internal.range import TickRange
589
590 value = TickRange()
591 value.start = long(self.first)
592 value.end = long(self.second)
593 return value
594
595# Boolean parameter type. Python doesn't let you subclass bool, since
596# it doesn't want to let you create multiple instances of True and
597# False. Thus this is a little more complicated than String.
598class Bool(ParamValue):
599 cxx_type = 'bool'
600 def __init__(self, value):
601 try:
602 self.value = convert.toBool(value)
603 except TypeError:
604 self.value = bool(value)
605
606 def getValue(self):
607 return bool(self.value)
608
609 def __str__(self):
610 return str(self.value)
611
612 def ini_str(self):
613 if self.value:
614 return 'true'
615 return 'false'
616
617def IncEthernetAddr(addr, val = 1):
618 bytes = map(lambda x: int(x, 16), addr.split(':'))
619 bytes[5] += val
620 for i in (5, 4, 3, 2, 1):
621 val,rem = divmod(bytes[i], 256)
622 bytes[i] = rem
623 if val == 0:
624 break
625 bytes[i - 1] += val
626 assert(bytes[0] <= 255)
627 return ':'.join(map(lambda x: '%02x' % x, bytes))
628
629_NextEthernetAddr = "00:90:00:00:00:01"
630def NextEthernetAddr():
631 global _NextEthernetAddr
632
633 value = _NextEthernetAddr
634 _NextEthernetAddr = IncEthernetAddr(_NextEthernetAddr, 1)
635 return value
636
637class EthernetAddr(ParamValue):
638 cxx_type = 'Net::EthAddr'
639
640 @classmethod
641 def cxx_predecls(cls, code):
642 code('#include "base/inet.hh"')
643
644 @classmethod
645 def swig_predecls(cls, code):
646 code('%include "python/swig/inet.i"')
647
648 def __init__(self, value):
649 if value == NextEthernetAddr:
650 self.value = value
651 return
652
653 if not isinstance(value, str):
654 raise TypeError, "expected an ethernet address and didn't get one"
655
656 bytes = value.split(':')
657 if len(bytes) != 6:
658 raise TypeError, 'invalid ethernet address %s' % value
659
660 for byte in bytes:
661 if not 0 <= int(byte) <= 0xff:
662 raise TypeError, 'invalid ethernet address %s' % value
663
664 self.value = value
665
666 def unproxy(self, base):
667 if self.value == NextEthernetAddr:
668 return EthernetAddr(self.value())
669 return self
670
671 def getValue(self):
672 from m5.internal.params import EthAddr
673 return EthAddr(self.value)
674
675 def ini_str(self):
676 return self.value
677
678# When initializing an IpAddress, pass in an existing IpAddress, a string of
679# the form "a.b.c.d", or an integer representing an IP.
680class IpAddress(ParamValue):
681 cxx_type = 'Net::IpAddress'
682
683 @classmethod
684 def cxx_predecls(cls, code):
685 code('#include "base/inet.hh"')
686
687 @classmethod
688 def swig_predecls(cls, code):
689 code('%include "python/swig/inet.i"')
690
691 def __init__(self, value):
692 if isinstance(value, IpAddress):
693 self.ip = value.ip
694 else:
695 try:
696 self.ip = convert.toIpAddress(value)
697 except TypeError:
698 self.ip = long(value)
699 self.verifyIp()
700
701 def __str__(self):
702 tup = [(self.ip >> i) & 0xff for i in (24, 16, 8, 0)]
703 return '%d.%d.%d.%d' % tuple(tup)
704
705 def __eq__(self, other):
706 if isinstance(other, IpAddress):
707 return self.ip == other.ip
708 elif isinstance(other, str):
709 try:
710 return self.ip == convert.toIpAddress(other)
711 except:
712 return False
713 else:
714 return self.ip == other
715
716 def __ne__(self, other):
717 return not (self == other)
718
719 def verifyIp(self):
720 if self.ip < 0 or self.ip >= (1 << 32):
721 raise TypeError, "invalid ip address %#08x" % self.ip
722
723 def getValue(self):
724 from m5.internal.params import IpAddress
725 return IpAddress(self.ip)
726
727# When initializing an IpNetmask, pass in an existing IpNetmask, a string of
728# the form "a.b.c.d/n" or "a.b.c.d/e.f.g.h", or an ip and netmask as
729# positional or keyword arguments.
730class IpNetmask(IpAddress):
731 cxx_type = 'Net::IpNetmask'
732
733 @classmethod
734 def cxx_predecls(cls, code):
735 code('#include "base/inet.hh"')
736
737 @classmethod
738 def swig_predecls(cls, code):
739 code('%include "python/swig/inet.i"')
740
741 def __init__(self, *args, **kwargs):
742 def handle_kwarg(self, kwargs, key, elseVal = None):
743 if key in kwargs:
744 setattr(self, key, kwargs.pop(key))
745 elif elseVal:
746 setattr(self, key, elseVal)
747 else:
748 raise TypeError, "No value set for %s" % key
749
750 if len(args) == 0:
751 handle_kwarg(self, kwargs, 'ip')
752 handle_kwarg(self, kwargs, 'netmask')
753
754 elif len(args) == 1:
755 if kwargs:
756 if not 'ip' in kwargs and not 'netmask' in kwargs:
757 raise TypeError, "Invalid arguments"
758 handle_kwarg(self, kwargs, 'ip', args[0])
759 handle_kwarg(self, kwargs, 'netmask', args[0])
760 elif isinstance(args[0], IpNetmask):
761 self.ip = args[0].ip
762 self.netmask = args[0].netmask
763 else:
764 (self.ip, self.netmask) = convert.toIpNetmask(args[0])
765
766 elif len(args) == 2:
767 self.ip = args[0]
768 self.netmask = args[1]
769 else:
770 raise TypeError, "Too many arguments specified"
771
772 if kwargs:
773 raise TypeError, "Too many keywords: %s" % kwargs.keys()
774
775 self.verify()
776
777 def __str__(self):
778 return "%s/%d" % (super(IpNetmask, self).__str__(), self.netmask)
779
780 def __eq__(self, other):
781 if isinstance(other, IpNetmask):
782 return self.ip == other.ip and self.netmask == other.netmask
783 elif isinstance(other, str):
784 try:
785 return (self.ip, self.netmask) == convert.toIpNetmask(other)
786 except:
787 return False
788 else:
789 return False
790
791 def verify(self):
792 self.verifyIp()
793 if self.netmask < 0 or self.netmask > 32:
794 raise TypeError, "invalid netmask %d" % netmask
795
796 def getValue(self):
797 from m5.internal.params import IpNetmask
798 return IpNetmask(self.ip, self.netmask)
799
800# When initializing an IpWithPort, pass in an existing IpWithPort, a string of
801# the form "a.b.c.d:p", or an ip and port as positional or keyword arguments.
802class IpWithPort(IpAddress):
803 cxx_type = 'Net::IpWithPort'
804
805 @classmethod
806 def cxx_predecls(cls, code):
807 code('#include "base/inet.hh"')
808
809 @classmethod
810 def swig_predecls(cls, code):
811 code('%include "python/swig/inet.i"')
812
813 def __init__(self, *args, **kwargs):
814 def handle_kwarg(self, kwargs, key, elseVal = None):
815 if key in kwargs:
816 setattr(self, key, kwargs.pop(key))
817 elif elseVal:
818 setattr(self, key, elseVal)
819 else:
820 raise TypeError, "No value set for %s" % key
821
822 if len(args) == 0:
823 handle_kwarg(self, kwargs, 'ip')
824 handle_kwarg(self, kwargs, 'port')
825
826 elif len(args) == 1:
827 if kwargs:
828 if not 'ip' in kwargs and not 'port' in kwargs:
829 raise TypeError, "Invalid arguments"
830 handle_kwarg(self, kwargs, 'ip', args[0])
831 handle_kwarg(self, kwargs, 'port', args[0])
832 elif isinstance(args[0], IpWithPort):
833 self.ip = args[0].ip
834 self.port = args[0].port
835 else:
836 (self.ip, self.port) = convert.toIpWithPort(args[0])
837
838 elif len(args) == 2:
839 self.ip = args[0]
840 self.port = args[1]
841 else:
842 raise TypeError, "Too many arguments specified"
843
844 if kwargs:
845 raise TypeError, "Too many keywords: %s" % kwargs.keys()
846
847 self.verify()
848
849 def __str__(self):
850 return "%s:%d" % (super(IpWithPort, self).__str__(), self.port)
851
852 def __eq__(self, other):
853 if isinstance(other, IpWithPort):
854 return self.ip == other.ip and self.port == other.port
855 elif isinstance(other, str):
856 try:
857 return (self.ip, self.port) == convert.toIpWithPort(other)
858 except:
859 return False
860 else:
861 return False
862
863 def verify(self):
864 self.verifyIp()
865 if self.port < 0 or self.port > 0xffff:
866 raise TypeError, "invalid port %d" % self.port
867
868 def getValue(self):
869 from m5.internal.params import IpWithPort
870 return IpWithPort(self.ip, self.port)
871
872time_formats = [ "%a %b %d %H:%M:%S %Z %Y",
873 "%a %b %d %H:%M:%S %Z %Y",
874 "%Y/%m/%d %H:%M:%S",
875 "%Y/%m/%d %H:%M",
876 "%Y/%m/%d",
877 "%m/%d/%Y %H:%M:%S",
878 "%m/%d/%Y %H:%M",
879 "%m/%d/%Y",
880 "%m/%d/%y %H:%M:%S",
881 "%m/%d/%y %H:%M",
882 "%m/%d/%y"]
883
884
885def parse_time(value):
886 from time import gmtime, strptime, struct_time, time
887 from datetime import datetime, date
888
889 if isinstance(value, struct_time):
890 return value
891
892 if isinstance(value, (int, long)):
893 return gmtime(value)
894
895 if isinstance(value, (datetime, date)):
896 return value.timetuple()
897
898 if isinstance(value, str):
899 if value in ('Now', 'Today'):
900 return time.gmtime(time.time())
901
902 for format in time_formats:
903 try:
904 return strptime(value, format)
905 except ValueError:
906 pass
907
908 raise ValueError, "Could not parse '%s' as a time" % value
909
910class Time(ParamValue):
911 cxx_type = 'tm'
912
913 @classmethod
914 def cxx_predecls(cls, code):
915 code('#include <time.h>')
916
917 @classmethod
918 def swig_predecls(cls, code):
919 code('%include "python/swig/time.i"')
920
921 def __init__(self, value):
922 self.value = parse_time(value)
923
924 def getValue(self):
925 from m5.internal.params import tm
926
927 c_time = tm()
928 py_time = self.value
929
930 # UNIX is years since 1900
931 c_time.tm_year = py_time.tm_year - 1900;
932
933 # Python starts at 1, UNIX starts at 0
934 c_time.tm_mon = py_time.tm_mon - 1;
935 c_time.tm_mday = py_time.tm_mday;
936 c_time.tm_hour = py_time.tm_hour;
937 c_time.tm_min = py_time.tm_min;
938 c_time.tm_sec = py_time.tm_sec;
939
940 # Python has 0 as Monday, UNIX is 0 as sunday
941 c_time.tm_wday = py_time.tm_wday + 1
942 if c_time.tm_wday > 6:
943 c_time.tm_wday -= 7;
944
945 # Python starts at 1, Unix starts at 0
946 c_time.tm_yday = py_time.tm_yday - 1;
947
948 return c_time
949
950 def __str__(self):
951 return time.asctime(self.value)
952
953 def ini_str(self):
954 return str(self)
955
956# Enumerated types are a little more complex. The user specifies the
957# type as Enum(foo) where foo is either a list or dictionary of
958# alternatives (typically strings, but not necessarily so). (In the
959# long run, the integer value of the parameter will be the list index
960# or the corresponding dictionary value. For now, since we only check
961# that the alternative is valid and then spit it into a .ini file,
962# there's not much point in using the dictionary.)
963
964# What Enum() must do is generate a new type encapsulating the
965# provided list/dictionary so that specific values of the parameter
966# can be instances of that type. We define two hidden internal
967# classes (_ListEnum and _DictEnum) to serve as base classes, then
968# derive the new type from the appropriate base class on the fly.
969
970allEnums = {}
971# Metaclass for Enum types
972class MetaEnum(MetaParamValue):
973 def __new__(mcls, name, bases, dict):
974 assert name not in allEnums
975
976 cls = super(MetaEnum, mcls).__new__(mcls, name, bases, dict)
977 allEnums[name] = cls
978 return cls
979
980 def __init__(cls, name, bases, init_dict):
981 if init_dict.has_key('map'):
982 if not isinstance(cls.map, dict):
983 raise TypeError, "Enum-derived class attribute 'map' " \
984 "must be of type dict"
985 # build list of value strings from map
986 cls.vals = cls.map.keys()
987 cls.vals.sort()
988 elif init_dict.has_key('vals'):
989 if not isinstance(cls.vals, list):
990 raise TypeError, "Enum-derived class attribute 'vals' " \
991 "must be of type list"
992 # build string->value map from vals sequence
993 cls.map = {}
994 for idx,val in enumerate(cls.vals):
995 cls.map[val] = idx
996 else:
997 raise TypeError, "Enum-derived class must define "\
998 "attribute 'map' or 'vals'"
999
1000 cls.cxx_type = 'Enums::%s' % name
1001
1002 super(MetaEnum, cls).__init__(name, bases, init_dict)
1003
1004 # Generate C++ class declaration for this enum type.
1005 # Note that we wrap the enum in a class/struct to act as a namespace,
1006 # so that the enum strings can be brief w/o worrying about collisions.
1007 def cxx_decl(cls, code):
1008 name = cls.__name__
1009 code('''\
1010#ifndef __ENUM__${name}__
1011#define __ENUM__${name}__
1012
1013namespace Enums {
1014 enum $name {
1015''')
1016 code.indent(2)
1017 for val in cls.vals:
1018 code('$val = ${{cls.map[val]}},')
1019 code('Num_$name = ${{len(cls.vals)}},')
1020 code.dedent(2)
1021 code('''\
1022 };
1023extern const char *${name}Strings[Num_${name}];
1024}
1025
1026#endif // __ENUM__${name}__
1027''')
1028
1029 def cxx_def(cls, code):
1030 name = cls.__name__
1031 code('''\
1032#include "enums/$name.hh"
1033namespace Enums {
1034 const char *${name}Strings[Num_${name}] =
1035 {
1036''')
1037 code.indent(2)
1038 for val in cls.vals:
1039 code('"$val",')
1040 code.dedent(2)
1041 code('''
1042 };
1043} // namespace Enums
1044''')
1045
1046# Base class for enum types.
1047class Enum(ParamValue):
1048 __metaclass__ = MetaEnum
1049 vals = []
1050
1051 def __init__(self, value):
1052 if value not in self.map:
1053 raise TypeError, "Enum param got bad value '%s' (not in %s)" \
1054 % (value, self.vals)
1055 self.value = value
1056
1057 @classmethod
1058 def cxx_predecls(cls, code):
1059 code('#include "enums/$0.hh"', cls.__name__)
1060
1061 @classmethod
1062 def swig_predecls(cls, code):
1063 code('%import "python/m5/internal/enum_$0.i"', cls.__name__)
1064
1065 def getValue(self):
1066 return int(self.map[self.value])
1067
1068 def __str__(self):
1069 return self.value
1070
1071# how big does a rounding error need to be before we warn about it?
1072frequency_tolerance = 0.001 # 0.1%
1073
1074class TickParamValue(NumericParamValue):
1075 cxx_type = 'Tick'
1076
1077 @classmethod
1078 def cxx_predecls(cls, code):
1079 code('#include "base/types.hh"')
1080
1081 @classmethod
1082 def swig_predecls(cls, code):
1083 code('%import "stdint.i"')
1084 code('%import "base/types.hh"')
1085
1086 def getValue(self):
1087 return long(self.value)
1088
1089class Latency(TickParamValue):
1090 def __init__(self, value):
1091 if isinstance(value, (Latency, Clock)):
1092 self.ticks = value.ticks
1093 self.value = value.value
1094 elif isinstance(value, Frequency):
1095 self.ticks = value.ticks
1096 self.value = 1.0 / value.value
1097 elif value.endswith('t'):
1098 self.ticks = True
1099 self.value = int(value[:-1])
1100 else:
1101 self.ticks = False
1102 self.value = convert.toLatency(value)
1103
1104 def __getattr__(self, attr):
1105 if attr in ('latency', 'period'):
1106 return self
1107 if attr == 'frequency':
1108 return Frequency(self)
1109 raise AttributeError, "Latency object has no attribute '%s'" % attr
1110
1111 def getValue(self):
1112 if self.ticks or self.value == 0:
1113 value = self.value
1114 else:
1115 value = ticks.fromSeconds(self.value)
1116 return long(value)
1117
1118 # convert latency to ticks
1119 def ini_str(self):
1120 return '%d' % self.getValue()
1121
1122class Frequency(TickParamValue):
1123 def __init__(self, value):
1124 if isinstance(value, (Latency, Clock)):
1125 if value.value == 0:
1126 self.value = 0
1127 else:
1128 self.value = 1.0 / value.value
1129 self.ticks = value.ticks
1130 elif isinstance(value, Frequency):
1131 self.value = value.value
1132 self.ticks = value.ticks
1133 else:
1134 self.ticks = False
1135 self.value = convert.toFrequency(value)
1136
1137 def __getattr__(self, attr):
1138 if attr == 'frequency':
1139 return self
1140 if attr in ('latency', 'period'):
1141 return Latency(self)
1142 raise AttributeError, "Frequency object has no attribute '%s'" % attr
1143
1144 # convert latency to ticks
1145 def getValue(self):
1146 if self.ticks or self.value == 0:
1147 value = self.value
1148 else:
1149 value = ticks.fromSeconds(1.0 / self.value)
1150 return long(value)
1151
1152 def ini_str(self):
1153 return '%d' % self.getValue()
1154
1155# A generic frequency and/or Latency value. Value is stored as a latency,
1156# but to avoid ambiguity this object does not support numeric ops (* or /).
1157# An explicit conversion to a Latency or Frequency must be made first.
1158class Clock(ParamValue):
1159 cxx_type = 'Tick'
1160
1161 @classmethod
1162 def cxx_predecls(cls, code):
1163 code('#include "base/types.hh"')
1164
1165 @classmethod
1166 def swig_predecls(cls, code):
1167 code('%import "stdint.i"')
1168 code('%import "base/types.hh"')
1169
1170 def __init__(self, value):
1171 if isinstance(value, (Latency, Clock)):
1172 self.ticks = value.ticks
1173 self.value = value.value
1174 elif isinstance(value, Frequency):
1175 self.ticks = value.ticks
1176 self.value = 1.0 / value.value
1177 elif value.endswith('t'):
1178 self.ticks = True
1179 self.value = int(value[:-1])
1180 else:
1181 self.ticks = False
1182 self.value = convert.anyToLatency(value)
1183
1184 def __getattr__(self, attr):
1185 if attr == 'frequency':
1186 return Frequency(self)
1187 if attr in ('latency', 'period'):
1188 return Latency(self)
1189 raise AttributeError, "Frequency object has no attribute '%s'" % attr
1190
1191 def getValue(self):
1192 return self.period.getValue()
1193
1194 def ini_str(self):
1195 return self.period.ini_str()
1196
1197class NetworkBandwidth(float,ParamValue):
1198 cxx_type = 'float'
1199 def __new__(cls, value):
1200 # convert to bits per second
1201 val = convert.toNetworkBandwidth(value)
1202 return super(cls, NetworkBandwidth).__new__(cls, val)
1203
1204 def __str__(self):
1205 return str(self.val)
1206
1207 def getValue(self):
1208 # convert to seconds per byte
1209 value = 8.0 / float(self)
1210 # convert to ticks per byte
1211 value = ticks.fromSeconds(value)
1212 return float(value)
1213
1214 def ini_str(self):
1215 return '%f' % self.getValue()
1216
1217class MemoryBandwidth(float,ParamValue):
1218 cxx_type = 'float'
1219 def __new__(cls, value):
1220 # convert to bytes per second
1221 val = convert.toMemoryBandwidth(value)
1222 return super(cls, MemoryBandwidth).__new__(cls, val)
1223
1224 def __str__(self):
1225 return str(self.val)
1226
1227 def getValue(self):
1228 # convert to seconds per byte
1229 value = float(self)
1230 if value:
1231 value = 1.0 / float(self)
1232 # convert to ticks per byte
1233 value = ticks.fromSeconds(value)
1234 return float(value)
1235
1236 def ini_str(self):
1237 return '%f' % self.getValue()
1238
1239#
1240# "Constants"... handy aliases for various values.
1241#
1242
1243# Special class for NULL pointers. Note the special check in
1244# make_param_value() above that lets these be assigned where a
1245# SimObject is required.
1246# only one copy of a particular node
1247class NullSimObject(object):
1248 __metaclass__ = Singleton
1249
1250 def __call__(cls):
1251 return cls
1252
1253 def _instantiate(self, parent = None, path = ''):
1254 pass
1255
1256 def ini_str(self):
1257 return 'Null'
1258
1259 def unproxy(self, base):
1260 return self
1261
1262 def set_path(self, parent, name):
1263 pass
1264
1265 def __str__(self):
1266 return 'Null'
1267
1268 def getValue(self):
1269 return None
1270
1271# The only instance you'll ever need...
1272NULL = NullSimObject()
1273
1274def isNullPointer(value):
1275 return isinstance(value, NullSimObject)
1276
1277# Some memory range specifications use this as a default upper bound.
1278MaxAddr = Addr.max
1279MaxTick = Tick.max
1280AllMemory = AddrRange(0, MaxAddr)
1281
1282
1283#####################################################################
1284#
1285# Port objects
1286#
1287# Ports are used to interconnect objects in the memory system.
1288#
1289#####################################################################
1290
1291# Port reference: encapsulates a reference to a particular port on a
1292# particular SimObject.
1293class PortRef(object):
1294 def __init__(self, simobj, name):
1295 assert(isSimObject(simobj) or isSimObjectClass(simobj))
1296 self.simobj = simobj
1297 self.name = name
1298 self.peer = None # not associated with another port yet
1299 self.ccConnected = False # C++ port connection done?
1300 self.index = -1 # always -1 for non-vector ports
1301
1302 def __str__(self):
1303 return '%s.%s' % (self.simobj, self.name)
1304
1305 # for config.ini, print peer's name (not ours)
1306 def ini_str(self):
1307 return str(self.peer)
1308
1309 def __getattr__(self, attr):
1310 if attr == 'peerObj':
1311 # shorthand for proxies
1312 return self.peer.simobj
1313 raise AttributeError, "'%s' object has no attribute '%s'" % \
1314 (self.__class__.__name__, attr)
1315
1316 # Full connection is symmetric (both ways). Called via
1317 # SimObject.__setattr__ as a result of a port assignment, e.g.,
1318 # "obj1.portA = obj2.portB", or via VectorPortElementRef.__setitem__,
1319 # e.g., "obj1.portA[3] = obj2.portB".
1320 def connect(self, other):
1321 if isinstance(other, VectorPortRef):
1322 # reference to plain VectorPort is implicit append
1323 other = other._get_next()
1324 if self.peer and not proxy.isproxy(self.peer):
1325 print "warning: overwriting port", self, \
1326 "value", self.peer, "with", other
1327 self.peer.peer = None
1328 self.peer = other
1329 if proxy.isproxy(other):
1330 other.set_param_desc(PortParamDesc())
1331 elif isinstance(other, PortRef):
1332 if other.peer is not self:
1333 other.connect(self)
1334 else:
1335 raise TypeError, \
1336 "assigning non-port reference '%s' to port '%s'" \
1337 % (other, self)
1338
1339 def clone(self, simobj, memo):
1340 if memo.has_key(self):
1341 return memo[self]
1342 newRef = copy.copy(self)
1343 memo[self] = newRef
1344 newRef.simobj = simobj
1345 assert(isSimObject(newRef.simobj))
1346 if self.peer and not proxy.isproxy(self.peer):
1347 peerObj = self.peer.simobj(_memo=memo)
1348 newRef.peer = self.peer.clone(peerObj, memo)
1349 assert(not isinstance(newRef.peer, VectorPortRef))
1350 return newRef
1351
1352 def unproxy(self, simobj):
1353 assert(simobj is self.simobj)
1354 if proxy.isproxy(self.peer):
1355 try:
1356 realPeer = self.peer.unproxy(self.simobj)
1357 except:
1358 print "Error in unproxying port '%s' of %s" % \
1359 (self.name, self.simobj.path())
1360 raise
1361 self.connect(realPeer)
1362
1363 # Call C++ to create corresponding port connection between C++ objects
1364 def ccConnect(self):
1365 from m5.internal.params import connectPorts
1366
1367 if self.ccConnected: # already done this
1368 return
1369 peer = self.peer
1370 if not self.peer: # nothing to connect to
1371 return
1372 try:
1373 connectPorts(self.simobj.getCCObject(), self.name, self.index,
1374 peer.simobj.getCCObject(), peer.name, peer.index)
1375 except:
1376 print "Error connecting port %s.%s to %s.%s" % \
1377 (self.simobj.path(), self.name,
1378 peer.simobj.path(), peer.name)
1379 raise
1380 self.ccConnected = True
1381 peer.ccConnected = True
1382
1383# A reference to an individual element of a VectorPort... much like a
1384# PortRef, but has an index.
1385class VectorPortElementRef(PortRef):
1386 def __init__(self, simobj, name, index):
1387 PortRef.__init__(self, simobj, name)
1388 self.index = index
1389
1390 def __str__(self):
1391 return '%s.%s[%d]' % (self.simobj, self.name, self.index)
1392
1393# A reference to a complete vector-valued port (not just a single element).
1394# Can be indexed to retrieve individual VectorPortElementRef instances.
1395class VectorPortRef(object):
1396 def __init__(self, simobj, name):
1397 assert(isSimObject(simobj) or isSimObjectClass(simobj))
1398 self.simobj = simobj
1399 self.name = name
1400 self.elements = []
1401
1402 def __str__(self):
1403 return '%s.%s[:]' % (self.simobj, self.name)
1404
1405 # for config.ini, print peer's name (not ours)
1406 def ini_str(self):
1407 return ' '.join([el.ini_str() for el in self.elements])
1408
1409 def __getitem__(self, key):
1410 if not isinstance(key, int):
1411 raise TypeError, "VectorPort index must be integer"
1412 if key >= len(self.elements):
1413 # need to extend list
1414 ext = [VectorPortElementRef(self.simobj, self.name, i)
1415 for i in range(len(self.elements), key+1)]
1416 self.elements.extend(ext)
1417 return self.elements[key]
1418
1419 def _get_next(self):
1420 return self[len(self.elements)]
1421
1422 def __setitem__(self, key, value):
1423 if not isinstance(key, int):
1424 raise TypeError, "VectorPort index must be integer"
1425 self[key].connect(value)
1426
1427 def connect(self, other):
1428 if isinstance(other, (list, tuple)):
1429 # Assign list of port refs to vector port.
1430 # For now, append them... not sure if that's the right semantics
1431 # or if it should replace the current vector.
1432 for ref in other:
1433 self._get_next().connect(ref)
1434 else:
1435 # scalar assignment to plain VectorPort is implicit append
1436 self._get_next().connect(other)
1437
1438 def clone(self, simobj, memo):
1439 if memo.has_key(self):
1440 return memo[self]
1441 newRef = copy.copy(self)
1442 memo[self] = newRef
1443 newRef.simobj = simobj
1444 assert(isSimObject(newRef.simobj))
1445 newRef.elements = [el.clone(simobj, memo) for el in self.elements]
1446 return newRef
1447
1448 def unproxy(self, simobj):
1449 [el.unproxy(simobj) for el in self.elements]
1450
1451 def ccConnect(self):
1452 [el.ccConnect() for el in self.elements]
1453
1454# Port description object. Like a ParamDesc object, this represents a
1455# logical port in the SimObject class, not a particular port on a
1456# SimObject instance. The latter are represented by PortRef objects.
1457class Port(object):
1458 # Port("description") or Port(default, "description")
1459 def __init__(self, *args):
1460 if len(args) == 1:
1461 self.desc = args[0]
1462 elif len(args) == 2:
1463 self.default = args[0]
1464 self.desc = args[1]
1465 else:
1466 raise TypeError, 'wrong number of arguments'
1467 # self.name is set by SimObject class on assignment
1468 # e.g., pio_port = Port("blah") sets self.name to 'pio_port'
1469
1470 # Generate a PortRef for this port on the given SimObject with the
1471 # given name
1472 def makeRef(self, simobj):
1473 return PortRef(simobj, self.name)
1474
1475 # Connect an instance of this port (on the given SimObject with
1476 # the given name) with the port described by the supplied PortRef
1477 def connect(self, simobj, ref):
1478 self.makeRef(simobj).connect(ref)
1479
1480# VectorPort description object. Like Port, but represents a vector
1481# of connections (e.g., as on a Bus).
1482class VectorPort(Port):
1483 def __init__(self, *args):
1484 Port.__init__(self, *args)
1485 self.isVec = True
1486
1487 def makeRef(self, simobj):
1488 return VectorPortRef(simobj, self.name)
1489
1490# 'Fake' ParamDesc for Port references to assign to the _pdesc slot of
1491# proxy objects (via set_param_desc()) so that proxy error messages
1492# make sense.
1493class PortParamDesc(object):
1494 __metaclass__ = Singleton
1495
1496 ptype_str = 'Port'
1497 ptype = Port
1498
1499baseEnums = allEnums.copy()
1500baseParams = allParams.copy()
1501
1502def clear():
1503 global allEnums, allParams
1504
1505 allEnums = baseEnums.copy()
1506 allParams = baseParams.copy()
1507
1508__all__ = ['Param', 'VectorParam',
1509 'Enum', 'Bool', 'String', 'Float',
1510 'Int', 'Unsigned', 'Int8', 'UInt8', 'Int16', 'UInt16',
1511 'Int32', 'UInt32', 'Int64', 'UInt64',
1512 'Counter', 'Addr', 'Tick', 'Percent',
1513 'TcpPort', 'UdpPort', 'EthernetAddr',
1514 'IpAddress', 'IpNetmask', 'IpWithPort',
1515 'MemorySize', 'MemorySize32',
1516 'Latency', 'Frequency', 'Clock',
1517 'NetworkBandwidth', 'MemoryBandwidth',
1518 'Range', 'AddrRange', 'TickRange',
1519 'MaxAddr', 'MaxTick', 'AllMemory',
1520 'Time',
1521 'NextEthernetAddr', 'NULL',
1522 'Port', 'VectorPort']
1523
1524import SimObject
2# Copyright (c) 2010-2011 Advanced Micro Devices, Inc.
3# All rights reserved.
4#
5# Redistribution and use in source and binary forms, with or without
6# modification, are permitted provided that the following conditions are
7# met: redistributions of source code must retain the above copyright
8# notice, this list of conditions and the following disclaimer;
9# redistributions in binary form must reproduce the above copyright
10# notice, this list of conditions and the following disclaimer in the
11# documentation and/or other materials provided with the distribution;
12# neither the name of the copyright holders nor the names of its
13# contributors may be used to endorse or promote products derived from
14# this software without specific prior written permission.
15#
16# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
18# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
19# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
20# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27#
28# Authors: Steve Reinhardt
29# Nathan Binkert
30# Gabe Black
31
32#####################################################################
33#
34# Parameter description classes
35#
36# The _params dictionary in each class maps parameter names to either
37# a Param or a VectorParam object. These objects contain the
38# parameter description string, the parameter type, and the default
39# value (if any). The convert() method on these objects is used to
40# force whatever value is assigned to the parameter to the appropriate
41# type.
42#
43# Note that the default values are loaded into the class's attribute
44# space when the parameter dictionary is initialized (in
45# MetaSimObject._new_param()); after that point they aren't used.
46#
47#####################################################################
48
49import copy
50import datetime
51import re
52import sys
53import time
54import math
55
56import proxy
57import ticks
58from util import *
59
60def isSimObject(*args, **kwargs):
61 return SimObject.isSimObject(*args, **kwargs)
62
63def isSimObjectSequence(*args, **kwargs):
64 return SimObject.isSimObjectSequence(*args, **kwargs)
65
66def isSimObjectClass(*args, **kwargs):
67 return SimObject.isSimObjectClass(*args, **kwargs)
68
69allParams = {}
70
71class MetaParamValue(type):
72 def __new__(mcls, name, bases, dct):
73 cls = super(MetaParamValue, mcls).__new__(mcls, name, bases, dct)
74 assert name not in allParams
75 allParams[name] = cls
76 return cls
77
78
79# Dummy base class to identify types that are legitimate for SimObject
80# parameters.
81class ParamValue(object):
82 __metaclass__ = MetaParamValue
83
84 @classmethod
85 def cxx_predecls(cls, code):
86 pass
87
88 @classmethod
89 def swig_predecls(cls, code):
90 pass
91
92 # default for printing to .ini file is regular string conversion.
93 # will be overridden in some cases
94 def ini_str(self):
95 return str(self)
96
97 # allows us to blithely call unproxy() on things without checking
98 # if they're really proxies or not
99 def unproxy(self, base):
100 return self
101
102# Regular parameter description.
103class ParamDesc(object):
104 file_ext = 'ptype'
105
106 def __init__(self, ptype_str, ptype, *args, **kwargs):
107 self.ptype_str = ptype_str
108 # remember ptype only if it is provided
109 if ptype != None:
110 self.ptype = ptype
111
112 if args:
113 if len(args) == 1:
114 self.desc = args[0]
115 elif len(args) == 2:
116 self.default = args[0]
117 self.desc = args[1]
118 else:
119 raise TypeError, 'too many arguments'
120
121 if kwargs.has_key('desc'):
122 assert(not hasattr(self, 'desc'))
123 self.desc = kwargs['desc']
124 del kwargs['desc']
125
126 if kwargs.has_key('default'):
127 assert(not hasattr(self, 'default'))
128 self.default = kwargs['default']
129 del kwargs['default']
130
131 if kwargs:
132 raise TypeError, 'extra unknown kwargs %s' % kwargs
133
134 if not hasattr(self, 'desc'):
135 raise TypeError, 'desc attribute missing'
136
137 def __getattr__(self, attr):
138 if attr == 'ptype':
139 ptype = SimObject.allClasses[self.ptype_str]
140 assert isSimObjectClass(ptype)
141 self.ptype = ptype
142 return ptype
143
144 raise AttributeError, "'%s' object has no attribute '%s'" % \
145 (type(self).__name__, attr)
146
147 def convert(self, value):
148 if isinstance(value, proxy.BaseProxy):
149 value.set_param_desc(self)
150 return value
151 if not hasattr(self, 'ptype') and isNullPointer(value):
152 # deferred evaluation of SimObject; continue to defer if
153 # we're just assigning a null pointer
154 return value
155 if isinstance(value, self.ptype):
156 return value
157 if isNullPointer(value) and isSimObjectClass(self.ptype):
158 return value
159 return self.ptype(value)
160
161 def cxx_predecls(self, code):
162 self.ptype.cxx_predecls(code)
163
164 def swig_predecls(self, code):
165 self.ptype.swig_predecls(code)
166
167 def cxx_decl(self, code):
168 code('${{self.ptype.cxx_type}} ${{self.name}};')
169
170# Vector-valued parameter description. Just like ParamDesc, except
171# that the value is a vector (list) of the specified type instead of a
172# single value.
173
174class VectorParamValue(list):
175 __metaclass__ = MetaParamValue
176 def __setattr__(self, attr, value):
177 raise AttributeError, \
178 "Not allowed to set %s on '%s'" % (attr, type(self).__name__)
179
180 def ini_str(self):
181 return ' '.join([v.ini_str() for v in self])
182
183 def getValue(self):
184 return [ v.getValue() for v in self ]
185
186 def unproxy(self, base):
187 if len(self) == 1 and isinstance(self[0], proxy.AllProxy):
188 return self[0].unproxy(base)
189 else:
190 return [v.unproxy(base) for v in self]
191
192class SimObjectVector(VectorParamValue):
193 # support clone operation
194 def __call__(self, **kwargs):
195 return SimObjectVector([v(**kwargs) for v in self])
196
197 def clear_parent(self, old_parent):
198 for v in self:
199 v.clear_parent(old_parent)
200
201 def set_parent(self, parent, name):
202 if len(self) == 1:
203 self[0].set_parent(parent, name)
204 else:
205 width = int(math.ceil(math.log(len(self))/math.log(10)))
206 for i,v in enumerate(self):
207 v.set_parent(parent, "%s%0*d" % (name, width, i))
208
209 def has_parent(self):
210 return reduce(lambda x,y: x and y, [v.has_parent() for v in self])
211
212 # return 'cpu0 cpu1' etc. for print_ini()
213 def get_name(self):
214 return ' '.join([v._name for v in self])
215
216 # By iterating through the constituent members of the vector here
217 # we can nicely handle iterating over all a SimObject's children
218 # without having to provide lots of special functions on
219 # SimObjectVector directly.
220 def descendants(self):
221 for v in self:
222 for obj in v.descendants():
223 yield obj
224
225class VectorParamDesc(ParamDesc):
226 file_ext = 'vptype'
227
228 # Convert assigned value to appropriate type. If the RHS is not a
229 # list or tuple, it generates a single-element list.
230 def convert(self, value):
231 if isinstance(value, (list, tuple)):
232 # list: coerce each element into new list
233 tmp_list = [ ParamDesc.convert(self, v) for v in value ]
234 else:
235 # singleton: coerce to a single-element list
236 tmp_list = [ ParamDesc.convert(self, value) ]
237
238 if isSimObjectSequence(tmp_list):
239 return SimObjectVector(tmp_list)
240 else:
241 return VectorParamValue(tmp_list)
242
243 def swig_predecls(self, code):
244 code('%import "vptype_${{self.ptype_str}}.i"')
245
246 def swig_decl(self, code):
247 code('%{')
248 self.ptype.cxx_predecls(code)
249 code('%}')
250 code()
251 self.ptype.swig_predecls(code)
252 code()
253 code('%include "std_vector.i"')
254 code()
255
256 ptype = self.ptype_str
257 cxx_type = self.ptype.cxx_type
258
259 code('''\
260%typemap(in) std::vector< $cxx_type >::value_type {
261 if (SWIG_ConvertPtr($$input, (void **)&$$1, $$1_descriptor, 0) == -1) {
262 if (SWIG_ConvertPtr($$input, (void **)&$$1,
263 $$descriptor($cxx_type), 0) == -1) {
264 return NULL;
265 }
266 }
267}
268
269%typemap(in) std::vector< $cxx_type >::value_type * {
270 if (SWIG_ConvertPtr($$input, (void **)&$$1, $$1_descriptor, 0) == -1) {
271 if (SWIG_ConvertPtr($$input, (void **)&$$1,
272 $$descriptor($cxx_type *), 0) == -1) {
273 return NULL;
274 }
275 }
276}
277''')
278
279 code('%template(vector_$ptype) std::vector< $cxx_type >;')
280
281 def cxx_predecls(self, code):
282 code('#include <vector>')
283 self.ptype.cxx_predecls(code)
284
285 def cxx_decl(self, code):
286 code('std::vector< ${{self.ptype.cxx_type}} > ${{self.name}};')
287
288class ParamFactory(object):
289 def __init__(self, param_desc_class, ptype_str = None):
290 self.param_desc_class = param_desc_class
291 self.ptype_str = ptype_str
292
293 def __getattr__(self, attr):
294 if self.ptype_str:
295 attr = self.ptype_str + '.' + attr
296 return ParamFactory(self.param_desc_class, attr)
297
298 # E.g., Param.Int(5, "number of widgets")
299 def __call__(self, *args, **kwargs):
300 ptype = None
301 try:
302 ptype = allParams[self.ptype_str]
303 except KeyError:
304 # if name isn't defined yet, assume it's a SimObject, and
305 # try to resolve it later
306 pass
307 return self.param_desc_class(self.ptype_str, ptype, *args, **kwargs)
308
309Param = ParamFactory(ParamDesc)
310VectorParam = ParamFactory(VectorParamDesc)
311
312#####################################################################
313#
314# Parameter Types
315#
316# Though native Python types could be used to specify parameter types
317# (the 'ptype' field of the Param and VectorParam classes), it's more
318# flexible to define our own set of types. This gives us more control
319# over how Python expressions are converted to values (via the
320# __init__() constructor) and how these values are printed out (via
321# the __str__() conversion method).
322#
323#####################################################################
324
325# String-valued parameter. Just mixin the ParamValue class with the
326# built-in str class.
327class String(ParamValue,str):
328 cxx_type = 'std::string'
329
330 @classmethod
331 def cxx_predecls(self, code):
332 code('#include <string>')
333
334 @classmethod
335 def swig_predecls(cls, code):
336 code('%include "std_string.i"')
337
338 def getValue(self):
339 return self
340
341# superclass for "numeric" parameter values, to emulate math
342# operations in a type-safe way. e.g., a Latency times an int returns
343# a new Latency object.
344class NumericParamValue(ParamValue):
345 def __str__(self):
346 return str(self.value)
347
348 def __float__(self):
349 return float(self.value)
350
351 def __long__(self):
352 return long(self.value)
353
354 def __int__(self):
355 return int(self.value)
356
357 # hook for bounds checking
358 def _check(self):
359 return
360
361 def __mul__(self, other):
362 newobj = self.__class__(self)
363 newobj.value *= other
364 newobj._check()
365 return newobj
366
367 __rmul__ = __mul__
368
369 def __div__(self, other):
370 newobj = self.__class__(self)
371 newobj.value /= other
372 newobj._check()
373 return newobj
374
375 def __sub__(self, other):
376 newobj = self.__class__(self)
377 newobj.value -= other
378 newobj._check()
379 return newobj
380
381# Metaclass for bounds-checked integer parameters. See CheckedInt.
382class CheckedIntType(MetaParamValue):
383 def __init__(cls, name, bases, dict):
384 super(CheckedIntType, cls).__init__(name, bases, dict)
385
386 # CheckedInt is an abstract base class, so we actually don't
387 # want to do any processing on it... the rest of this code is
388 # just for classes that derive from CheckedInt.
389 if name == 'CheckedInt':
390 return
391
392 if not (hasattr(cls, 'min') and hasattr(cls, 'max')):
393 if not (hasattr(cls, 'size') and hasattr(cls, 'unsigned')):
394 panic("CheckedInt subclass %s must define either\n" \
395 " 'min' and 'max' or 'size' and 'unsigned'\n",
396 name);
397 if cls.unsigned:
398 cls.min = 0
399 cls.max = 2 ** cls.size - 1
400 else:
401 cls.min = -(2 ** (cls.size - 1))
402 cls.max = (2 ** (cls.size - 1)) - 1
403
404# Abstract superclass for bounds-checked integer parameters. This
405# class is subclassed to generate parameter classes with specific
406# bounds. Initialization of the min and max bounds is done in the
407# metaclass CheckedIntType.__init__.
408class CheckedInt(NumericParamValue):
409 __metaclass__ = CheckedIntType
410
411 def _check(self):
412 if not self.min <= self.value <= self.max:
413 raise TypeError, 'Integer param out of bounds %d < %d < %d' % \
414 (self.min, self.value, self.max)
415
416 def __init__(self, value):
417 if isinstance(value, str):
418 self.value = convert.toInteger(value)
419 elif isinstance(value, (int, long, float, NumericParamValue)):
420 self.value = long(value)
421 else:
422 raise TypeError, "Can't convert object of type %s to CheckedInt" \
423 % type(value).__name__
424 self._check()
425
426 @classmethod
427 def cxx_predecls(cls, code):
428 # most derived types require this, so we just do it here once
429 code('#include "base/types.hh"')
430
431 @classmethod
432 def swig_predecls(cls, code):
433 # most derived types require this, so we just do it here once
434 code('%import "stdint.i"')
435 code('%import "base/types.hh"')
436
437 def getValue(self):
438 return long(self.value)
439
440class Int(CheckedInt): cxx_type = 'int'; size = 32; unsigned = False
441class Unsigned(CheckedInt): cxx_type = 'unsigned'; size = 32; unsigned = True
442
443class Int8(CheckedInt): cxx_type = 'int8_t'; size = 8; unsigned = False
444class UInt8(CheckedInt): cxx_type = 'uint8_t'; size = 8; unsigned = True
445class Int16(CheckedInt): cxx_type = 'int16_t'; size = 16; unsigned = False
446class UInt16(CheckedInt): cxx_type = 'uint16_t'; size = 16; unsigned = True
447class Int32(CheckedInt): cxx_type = 'int32_t'; size = 32; unsigned = False
448class UInt32(CheckedInt): cxx_type = 'uint32_t'; size = 32; unsigned = True
449class Int64(CheckedInt): cxx_type = 'int64_t'; size = 64; unsigned = False
450class UInt64(CheckedInt): cxx_type = 'uint64_t'; size = 64; unsigned = True
451
452class Counter(CheckedInt): cxx_type = 'Counter'; size = 64; unsigned = True
453class Tick(CheckedInt): cxx_type = 'Tick'; size = 64; unsigned = True
454class TcpPort(CheckedInt): cxx_type = 'uint16_t'; size = 16; unsigned = True
455class UdpPort(CheckedInt): cxx_type = 'uint16_t'; size = 16; unsigned = True
456
457class Percent(CheckedInt): cxx_type = 'int'; min = 0; max = 100
458
459class Float(ParamValue, float):
460 cxx_type = 'double'
461
462 def __init__(self, value):
463 if isinstance(value, (int, long, float, NumericParamValue, Float)):
464 self.value = float(value)
465 else:
466 raise TypeError, "Can't convert object of type %s to Float" \
467 % type(value).__name__
468
469 def getValue(self):
470 return float(self.value)
471
472class MemorySize(CheckedInt):
473 cxx_type = 'uint64_t'
474 size = 64
475 unsigned = True
476 def __init__(self, value):
477 if isinstance(value, MemorySize):
478 self.value = value.value
479 else:
480 self.value = convert.toMemorySize(value)
481 self._check()
482
483class MemorySize32(CheckedInt):
484 cxx_type = 'uint32_t'
485 size = 32
486 unsigned = True
487 def __init__(self, value):
488 if isinstance(value, MemorySize):
489 self.value = value.value
490 else:
491 self.value = convert.toMemorySize(value)
492 self._check()
493
494class Addr(CheckedInt):
495 cxx_type = 'Addr'
496 size = 64
497 unsigned = True
498 def __init__(self, value):
499 if isinstance(value, Addr):
500 self.value = value.value
501 else:
502 try:
503 self.value = convert.toMemorySize(value)
504 except TypeError:
505 self.value = long(value)
506 self._check()
507 def __add__(self, other):
508 if isinstance(other, Addr):
509 return self.value + other.value
510 else:
511 return self.value + other
512
513
514class MetaRange(MetaParamValue):
515 def __init__(cls, name, bases, dict):
516 super(MetaRange, cls).__init__(name, bases, dict)
517 if name == 'Range':
518 return
519 cls.cxx_type = 'Range< %s >' % cls.type.cxx_type
520
521class Range(ParamValue):
522 __metaclass__ = MetaRange
523 type = Int # default; can be overridden in subclasses
524 def __init__(self, *args, **kwargs):
525 def handle_kwargs(self, kwargs):
526 if 'end' in kwargs:
527 self.second = self.type(kwargs.pop('end'))
528 elif 'size' in kwargs:
529 self.second = self.first + self.type(kwargs.pop('size')) - 1
530 else:
531 raise TypeError, "Either end or size must be specified"
532
533 if len(args) == 0:
534 self.first = self.type(kwargs.pop('start'))
535 handle_kwargs(self, kwargs)
536
537 elif len(args) == 1:
538 if kwargs:
539 self.first = self.type(args[0])
540 handle_kwargs(self, kwargs)
541 elif isinstance(args[0], Range):
542 self.first = self.type(args[0].first)
543 self.second = self.type(args[0].second)
544 elif isinstance(args[0], (list, tuple)):
545 self.first = self.type(args[0][0])
546 self.second = self.type(args[0][1])
547 else:
548 self.first = self.type(0)
549 self.second = self.type(args[0]) - 1
550
551 elif len(args) == 2:
552 self.first = self.type(args[0])
553 self.second = self.type(args[1])
554 else:
555 raise TypeError, "Too many arguments specified"
556
557 if kwargs:
558 raise TypeError, "too many keywords: %s" % kwargs.keys()
559
560 def __str__(self):
561 return '%s:%s' % (self.first, self.second)
562
563 @classmethod
564 def cxx_predecls(cls, code):
565 cls.type.cxx_predecls(code)
566 code('#include "base/range.hh"')
567
568 @classmethod
569 def swig_predecls(cls, code):
570 cls.type.swig_predecls(code)
571 code('%import "python/swig/range.i"')
572
573class AddrRange(Range):
574 type = Addr
575
576 def getValue(self):
577 from m5.internal.range import AddrRange
578
579 value = AddrRange()
580 value.start = long(self.first)
581 value.end = long(self.second)
582 return value
583
584class TickRange(Range):
585 type = Tick
586
587 def getValue(self):
588 from m5.internal.range import TickRange
589
590 value = TickRange()
591 value.start = long(self.first)
592 value.end = long(self.second)
593 return value
594
595# Boolean parameter type. Python doesn't let you subclass bool, since
596# it doesn't want to let you create multiple instances of True and
597# False. Thus this is a little more complicated than String.
598class Bool(ParamValue):
599 cxx_type = 'bool'
600 def __init__(self, value):
601 try:
602 self.value = convert.toBool(value)
603 except TypeError:
604 self.value = bool(value)
605
606 def getValue(self):
607 return bool(self.value)
608
609 def __str__(self):
610 return str(self.value)
611
612 def ini_str(self):
613 if self.value:
614 return 'true'
615 return 'false'
616
617def IncEthernetAddr(addr, val = 1):
618 bytes = map(lambda x: int(x, 16), addr.split(':'))
619 bytes[5] += val
620 for i in (5, 4, 3, 2, 1):
621 val,rem = divmod(bytes[i], 256)
622 bytes[i] = rem
623 if val == 0:
624 break
625 bytes[i - 1] += val
626 assert(bytes[0] <= 255)
627 return ':'.join(map(lambda x: '%02x' % x, bytes))
628
629_NextEthernetAddr = "00:90:00:00:00:01"
630def NextEthernetAddr():
631 global _NextEthernetAddr
632
633 value = _NextEthernetAddr
634 _NextEthernetAddr = IncEthernetAddr(_NextEthernetAddr, 1)
635 return value
636
637class EthernetAddr(ParamValue):
638 cxx_type = 'Net::EthAddr'
639
640 @classmethod
641 def cxx_predecls(cls, code):
642 code('#include "base/inet.hh"')
643
644 @classmethod
645 def swig_predecls(cls, code):
646 code('%include "python/swig/inet.i"')
647
648 def __init__(self, value):
649 if value == NextEthernetAddr:
650 self.value = value
651 return
652
653 if not isinstance(value, str):
654 raise TypeError, "expected an ethernet address and didn't get one"
655
656 bytes = value.split(':')
657 if len(bytes) != 6:
658 raise TypeError, 'invalid ethernet address %s' % value
659
660 for byte in bytes:
661 if not 0 <= int(byte) <= 0xff:
662 raise TypeError, 'invalid ethernet address %s' % value
663
664 self.value = value
665
666 def unproxy(self, base):
667 if self.value == NextEthernetAddr:
668 return EthernetAddr(self.value())
669 return self
670
671 def getValue(self):
672 from m5.internal.params import EthAddr
673 return EthAddr(self.value)
674
675 def ini_str(self):
676 return self.value
677
678# When initializing an IpAddress, pass in an existing IpAddress, a string of
679# the form "a.b.c.d", or an integer representing an IP.
680class IpAddress(ParamValue):
681 cxx_type = 'Net::IpAddress'
682
683 @classmethod
684 def cxx_predecls(cls, code):
685 code('#include "base/inet.hh"')
686
687 @classmethod
688 def swig_predecls(cls, code):
689 code('%include "python/swig/inet.i"')
690
691 def __init__(self, value):
692 if isinstance(value, IpAddress):
693 self.ip = value.ip
694 else:
695 try:
696 self.ip = convert.toIpAddress(value)
697 except TypeError:
698 self.ip = long(value)
699 self.verifyIp()
700
701 def __str__(self):
702 tup = [(self.ip >> i) & 0xff for i in (24, 16, 8, 0)]
703 return '%d.%d.%d.%d' % tuple(tup)
704
705 def __eq__(self, other):
706 if isinstance(other, IpAddress):
707 return self.ip == other.ip
708 elif isinstance(other, str):
709 try:
710 return self.ip == convert.toIpAddress(other)
711 except:
712 return False
713 else:
714 return self.ip == other
715
716 def __ne__(self, other):
717 return not (self == other)
718
719 def verifyIp(self):
720 if self.ip < 0 or self.ip >= (1 << 32):
721 raise TypeError, "invalid ip address %#08x" % self.ip
722
723 def getValue(self):
724 from m5.internal.params import IpAddress
725 return IpAddress(self.ip)
726
727# When initializing an IpNetmask, pass in an existing IpNetmask, a string of
728# the form "a.b.c.d/n" or "a.b.c.d/e.f.g.h", or an ip and netmask as
729# positional or keyword arguments.
730class IpNetmask(IpAddress):
731 cxx_type = 'Net::IpNetmask'
732
733 @classmethod
734 def cxx_predecls(cls, code):
735 code('#include "base/inet.hh"')
736
737 @classmethod
738 def swig_predecls(cls, code):
739 code('%include "python/swig/inet.i"')
740
741 def __init__(self, *args, **kwargs):
742 def handle_kwarg(self, kwargs, key, elseVal = None):
743 if key in kwargs:
744 setattr(self, key, kwargs.pop(key))
745 elif elseVal:
746 setattr(self, key, elseVal)
747 else:
748 raise TypeError, "No value set for %s" % key
749
750 if len(args) == 0:
751 handle_kwarg(self, kwargs, 'ip')
752 handle_kwarg(self, kwargs, 'netmask')
753
754 elif len(args) == 1:
755 if kwargs:
756 if not 'ip' in kwargs and not 'netmask' in kwargs:
757 raise TypeError, "Invalid arguments"
758 handle_kwarg(self, kwargs, 'ip', args[0])
759 handle_kwarg(self, kwargs, 'netmask', args[0])
760 elif isinstance(args[0], IpNetmask):
761 self.ip = args[0].ip
762 self.netmask = args[0].netmask
763 else:
764 (self.ip, self.netmask) = convert.toIpNetmask(args[0])
765
766 elif len(args) == 2:
767 self.ip = args[0]
768 self.netmask = args[1]
769 else:
770 raise TypeError, "Too many arguments specified"
771
772 if kwargs:
773 raise TypeError, "Too many keywords: %s" % kwargs.keys()
774
775 self.verify()
776
777 def __str__(self):
778 return "%s/%d" % (super(IpNetmask, self).__str__(), self.netmask)
779
780 def __eq__(self, other):
781 if isinstance(other, IpNetmask):
782 return self.ip == other.ip and self.netmask == other.netmask
783 elif isinstance(other, str):
784 try:
785 return (self.ip, self.netmask) == convert.toIpNetmask(other)
786 except:
787 return False
788 else:
789 return False
790
791 def verify(self):
792 self.verifyIp()
793 if self.netmask < 0 or self.netmask > 32:
794 raise TypeError, "invalid netmask %d" % netmask
795
796 def getValue(self):
797 from m5.internal.params import IpNetmask
798 return IpNetmask(self.ip, self.netmask)
799
800# When initializing an IpWithPort, pass in an existing IpWithPort, a string of
801# the form "a.b.c.d:p", or an ip and port as positional or keyword arguments.
802class IpWithPort(IpAddress):
803 cxx_type = 'Net::IpWithPort'
804
805 @classmethod
806 def cxx_predecls(cls, code):
807 code('#include "base/inet.hh"')
808
809 @classmethod
810 def swig_predecls(cls, code):
811 code('%include "python/swig/inet.i"')
812
813 def __init__(self, *args, **kwargs):
814 def handle_kwarg(self, kwargs, key, elseVal = None):
815 if key in kwargs:
816 setattr(self, key, kwargs.pop(key))
817 elif elseVal:
818 setattr(self, key, elseVal)
819 else:
820 raise TypeError, "No value set for %s" % key
821
822 if len(args) == 0:
823 handle_kwarg(self, kwargs, 'ip')
824 handle_kwarg(self, kwargs, 'port')
825
826 elif len(args) == 1:
827 if kwargs:
828 if not 'ip' in kwargs and not 'port' in kwargs:
829 raise TypeError, "Invalid arguments"
830 handle_kwarg(self, kwargs, 'ip', args[0])
831 handle_kwarg(self, kwargs, 'port', args[0])
832 elif isinstance(args[0], IpWithPort):
833 self.ip = args[0].ip
834 self.port = args[0].port
835 else:
836 (self.ip, self.port) = convert.toIpWithPort(args[0])
837
838 elif len(args) == 2:
839 self.ip = args[0]
840 self.port = args[1]
841 else:
842 raise TypeError, "Too many arguments specified"
843
844 if kwargs:
845 raise TypeError, "Too many keywords: %s" % kwargs.keys()
846
847 self.verify()
848
849 def __str__(self):
850 return "%s:%d" % (super(IpWithPort, self).__str__(), self.port)
851
852 def __eq__(self, other):
853 if isinstance(other, IpWithPort):
854 return self.ip == other.ip and self.port == other.port
855 elif isinstance(other, str):
856 try:
857 return (self.ip, self.port) == convert.toIpWithPort(other)
858 except:
859 return False
860 else:
861 return False
862
863 def verify(self):
864 self.verifyIp()
865 if self.port < 0 or self.port > 0xffff:
866 raise TypeError, "invalid port %d" % self.port
867
868 def getValue(self):
869 from m5.internal.params import IpWithPort
870 return IpWithPort(self.ip, self.port)
871
872time_formats = [ "%a %b %d %H:%M:%S %Z %Y",
873 "%a %b %d %H:%M:%S %Z %Y",
874 "%Y/%m/%d %H:%M:%S",
875 "%Y/%m/%d %H:%M",
876 "%Y/%m/%d",
877 "%m/%d/%Y %H:%M:%S",
878 "%m/%d/%Y %H:%M",
879 "%m/%d/%Y",
880 "%m/%d/%y %H:%M:%S",
881 "%m/%d/%y %H:%M",
882 "%m/%d/%y"]
883
884
885def parse_time(value):
886 from time import gmtime, strptime, struct_time, time
887 from datetime import datetime, date
888
889 if isinstance(value, struct_time):
890 return value
891
892 if isinstance(value, (int, long)):
893 return gmtime(value)
894
895 if isinstance(value, (datetime, date)):
896 return value.timetuple()
897
898 if isinstance(value, str):
899 if value in ('Now', 'Today'):
900 return time.gmtime(time.time())
901
902 for format in time_formats:
903 try:
904 return strptime(value, format)
905 except ValueError:
906 pass
907
908 raise ValueError, "Could not parse '%s' as a time" % value
909
910class Time(ParamValue):
911 cxx_type = 'tm'
912
913 @classmethod
914 def cxx_predecls(cls, code):
915 code('#include <time.h>')
916
917 @classmethod
918 def swig_predecls(cls, code):
919 code('%include "python/swig/time.i"')
920
921 def __init__(self, value):
922 self.value = parse_time(value)
923
924 def getValue(self):
925 from m5.internal.params import tm
926
927 c_time = tm()
928 py_time = self.value
929
930 # UNIX is years since 1900
931 c_time.tm_year = py_time.tm_year - 1900;
932
933 # Python starts at 1, UNIX starts at 0
934 c_time.tm_mon = py_time.tm_mon - 1;
935 c_time.tm_mday = py_time.tm_mday;
936 c_time.tm_hour = py_time.tm_hour;
937 c_time.tm_min = py_time.tm_min;
938 c_time.tm_sec = py_time.tm_sec;
939
940 # Python has 0 as Monday, UNIX is 0 as sunday
941 c_time.tm_wday = py_time.tm_wday + 1
942 if c_time.tm_wday > 6:
943 c_time.tm_wday -= 7;
944
945 # Python starts at 1, Unix starts at 0
946 c_time.tm_yday = py_time.tm_yday - 1;
947
948 return c_time
949
950 def __str__(self):
951 return time.asctime(self.value)
952
953 def ini_str(self):
954 return str(self)
955
956# Enumerated types are a little more complex. The user specifies the
957# type as Enum(foo) where foo is either a list or dictionary of
958# alternatives (typically strings, but not necessarily so). (In the
959# long run, the integer value of the parameter will be the list index
960# or the corresponding dictionary value. For now, since we only check
961# that the alternative is valid and then spit it into a .ini file,
962# there's not much point in using the dictionary.)
963
964# What Enum() must do is generate a new type encapsulating the
965# provided list/dictionary so that specific values of the parameter
966# can be instances of that type. We define two hidden internal
967# classes (_ListEnum and _DictEnum) to serve as base classes, then
968# derive the new type from the appropriate base class on the fly.
969
970allEnums = {}
971# Metaclass for Enum types
972class MetaEnum(MetaParamValue):
973 def __new__(mcls, name, bases, dict):
974 assert name not in allEnums
975
976 cls = super(MetaEnum, mcls).__new__(mcls, name, bases, dict)
977 allEnums[name] = cls
978 return cls
979
980 def __init__(cls, name, bases, init_dict):
981 if init_dict.has_key('map'):
982 if not isinstance(cls.map, dict):
983 raise TypeError, "Enum-derived class attribute 'map' " \
984 "must be of type dict"
985 # build list of value strings from map
986 cls.vals = cls.map.keys()
987 cls.vals.sort()
988 elif init_dict.has_key('vals'):
989 if not isinstance(cls.vals, list):
990 raise TypeError, "Enum-derived class attribute 'vals' " \
991 "must be of type list"
992 # build string->value map from vals sequence
993 cls.map = {}
994 for idx,val in enumerate(cls.vals):
995 cls.map[val] = idx
996 else:
997 raise TypeError, "Enum-derived class must define "\
998 "attribute 'map' or 'vals'"
999
1000 cls.cxx_type = 'Enums::%s' % name
1001
1002 super(MetaEnum, cls).__init__(name, bases, init_dict)
1003
1004 # Generate C++ class declaration for this enum type.
1005 # Note that we wrap the enum in a class/struct to act as a namespace,
1006 # so that the enum strings can be brief w/o worrying about collisions.
1007 def cxx_decl(cls, code):
1008 name = cls.__name__
1009 code('''\
1010#ifndef __ENUM__${name}__
1011#define __ENUM__${name}__
1012
1013namespace Enums {
1014 enum $name {
1015''')
1016 code.indent(2)
1017 for val in cls.vals:
1018 code('$val = ${{cls.map[val]}},')
1019 code('Num_$name = ${{len(cls.vals)}},')
1020 code.dedent(2)
1021 code('''\
1022 };
1023extern const char *${name}Strings[Num_${name}];
1024}
1025
1026#endif // __ENUM__${name}__
1027''')
1028
1029 def cxx_def(cls, code):
1030 name = cls.__name__
1031 code('''\
1032#include "enums/$name.hh"
1033namespace Enums {
1034 const char *${name}Strings[Num_${name}] =
1035 {
1036''')
1037 code.indent(2)
1038 for val in cls.vals:
1039 code('"$val",')
1040 code.dedent(2)
1041 code('''
1042 };
1043} // namespace Enums
1044''')
1045
1046# Base class for enum types.
1047class Enum(ParamValue):
1048 __metaclass__ = MetaEnum
1049 vals = []
1050
1051 def __init__(self, value):
1052 if value not in self.map:
1053 raise TypeError, "Enum param got bad value '%s' (not in %s)" \
1054 % (value, self.vals)
1055 self.value = value
1056
1057 @classmethod
1058 def cxx_predecls(cls, code):
1059 code('#include "enums/$0.hh"', cls.__name__)
1060
1061 @classmethod
1062 def swig_predecls(cls, code):
1063 code('%import "python/m5/internal/enum_$0.i"', cls.__name__)
1064
1065 def getValue(self):
1066 return int(self.map[self.value])
1067
1068 def __str__(self):
1069 return self.value
1070
1071# how big does a rounding error need to be before we warn about it?
1072frequency_tolerance = 0.001 # 0.1%
1073
1074class TickParamValue(NumericParamValue):
1075 cxx_type = 'Tick'
1076
1077 @classmethod
1078 def cxx_predecls(cls, code):
1079 code('#include "base/types.hh"')
1080
1081 @classmethod
1082 def swig_predecls(cls, code):
1083 code('%import "stdint.i"')
1084 code('%import "base/types.hh"')
1085
1086 def getValue(self):
1087 return long(self.value)
1088
1089class Latency(TickParamValue):
1090 def __init__(self, value):
1091 if isinstance(value, (Latency, Clock)):
1092 self.ticks = value.ticks
1093 self.value = value.value
1094 elif isinstance(value, Frequency):
1095 self.ticks = value.ticks
1096 self.value = 1.0 / value.value
1097 elif value.endswith('t'):
1098 self.ticks = True
1099 self.value = int(value[:-1])
1100 else:
1101 self.ticks = False
1102 self.value = convert.toLatency(value)
1103
1104 def __getattr__(self, attr):
1105 if attr in ('latency', 'period'):
1106 return self
1107 if attr == 'frequency':
1108 return Frequency(self)
1109 raise AttributeError, "Latency object has no attribute '%s'" % attr
1110
1111 def getValue(self):
1112 if self.ticks or self.value == 0:
1113 value = self.value
1114 else:
1115 value = ticks.fromSeconds(self.value)
1116 return long(value)
1117
1118 # convert latency to ticks
1119 def ini_str(self):
1120 return '%d' % self.getValue()
1121
1122class Frequency(TickParamValue):
1123 def __init__(self, value):
1124 if isinstance(value, (Latency, Clock)):
1125 if value.value == 0:
1126 self.value = 0
1127 else:
1128 self.value = 1.0 / value.value
1129 self.ticks = value.ticks
1130 elif isinstance(value, Frequency):
1131 self.value = value.value
1132 self.ticks = value.ticks
1133 else:
1134 self.ticks = False
1135 self.value = convert.toFrequency(value)
1136
1137 def __getattr__(self, attr):
1138 if attr == 'frequency':
1139 return self
1140 if attr in ('latency', 'period'):
1141 return Latency(self)
1142 raise AttributeError, "Frequency object has no attribute '%s'" % attr
1143
1144 # convert latency to ticks
1145 def getValue(self):
1146 if self.ticks or self.value == 0:
1147 value = self.value
1148 else:
1149 value = ticks.fromSeconds(1.0 / self.value)
1150 return long(value)
1151
1152 def ini_str(self):
1153 return '%d' % self.getValue()
1154
1155# A generic frequency and/or Latency value. Value is stored as a latency,
1156# but to avoid ambiguity this object does not support numeric ops (* or /).
1157# An explicit conversion to a Latency or Frequency must be made first.
1158class Clock(ParamValue):
1159 cxx_type = 'Tick'
1160
1161 @classmethod
1162 def cxx_predecls(cls, code):
1163 code('#include "base/types.hh"')
1164
1165 @classmethod
1166 def swig_predecls(cls, code):
1167 code('%import "stdint.i"')
1168 code('%import "base/types.hh"')
1169
1170 def __init__(self, value):
1171 if isinstance(value, (Latency, Clock)):
1172 self.ticks = value.ticks
1173 self.value = value.value
1174 elif isinstance(value, Frequency):
1175 self.ticks = value.ticks
1176 self.value = 1.0 / value.value
1177 elif value.endswith('t'):
1178 self.ticks = True
1179 self.value = int(value[:-1])
1180 else:
1181 self.ticks = False
1182 self.value = convert.anyToLatency(value)
1183
1184 def __getattr__(self, attr):
1185 if attr == 'frequency':
1186 return Frequency(self)
1187 if attr in ('latency', 'period'):
1188 return Latency(self)
1189 raise AttributeError, "Frequency object has no attribute '%s'" % attr
1190
1191 def getValue(self):
1192 return self.period.getValue()
1193
1194 def ini_str(self):
1195 return self.period.ini_str()
1196
1197class NetworkBandwidth(float,ParamValue):
1198 cxx_type = 'float'
1199 def __new__(cls, value):
1200 # convert to bits per second
1201 val = convert.toNetworkBandwidth(value)
1202 return super(cls, NetworkBandwidth).__new__(cls, val)
1203
1204 def __str__(self):
1205 return str(self.val)
1206
1207 def getValue(self):
1208 # convert to seconds per byte
1209 value = 8.0 / float(self)
1210 # convert to ticks per byte
1211 value = ticks.fromSeconds(value)
1212 return float(value)
1213
1214 def ini_str(self):
1215 return '%f' % self.getValue()
1216
1217class MemoryBandwidth(float,ParamValue):
1218 cxx_type = 'float'
1219 def __new__(cls, value):
1220 # convert to bytes per second
1221 val = convert.toMemoryBandwidth(value)
1222 return super(cls, MemoryBandwidth).__new__(cls, val)
1223
1224 def __str__(self):
1225 return str(self.val)
1226
1227 def getValue(self):
1228 # convert to seconds per byte
1229 value = float(self)
1230 if value:
1231 value = 1.0 / float(self)
1232 # convert to ticks per byte
1233 value = ticks.fromSeconds(value)
1234 return float(value)
1235
1236 def ini_str(self):
1237 return '%f' % self.getValue()
1238
1239#
1240# "Constants"... handy aliases for various values.
1241#
1242
1243# Special class for NULL pointers. Note the special check in
1244# make_param_value() above that lets these be assigned where a
1245# SimObject is required.
1246# only one copy of a particular node
1247class NullSimObject(object):
1248 __metaclass__ = Singleton
1249
1250 def __call__(cls):
1251 return cls
1252
1253 def _instantiate(self, parent = None, path = ''):
1254 pass
1255
1256 def ini_str(self):
1257 return 'Null'
1258
1259 def unproxy(self, base):
1260 return self
1261
1262 def set_path(self, parent, name):
1263 pass
1264
1265 def __str__(self):
1266 return 'Null'
1267
1268 def getValue(self):
1269 return None
1270
1271# The only instance you'll ever need...
1272NULL = NullSimObject()
1273
1274def isNullPointer(value):
1275 return isinstance(value, NullSimObject)
1276
1277# Some memory range specifications use this as a default upper bound.
1278MaxAddr = Addr.max
1279MaxTick = Tick.max
1280AllMemory = AddrRange(0, MaxAddr)
1281
1282
1283#####################################################################
1284#
1285# Port objects
1286#
1287# Ports are used to interconnect objects in the memory system.
1288#
1289#####################################################################
1290
1291# Port reference: encapsulates a reference to a particular port on a
1292# particular SimObject.
1293class PortRef(object):
1294 def __init__(self, simobj, name):
1295 assert(isSimObject(simobj) or isSimObjectClass(simobj))
1296 self.simobj = simobj
1297 self.name = name
1298 self.peer = None # not associated with another port yet
1299 self.ccConnected = False # C++ port connection done?
1300 self.index = -1 # always -1 for non-vector ports
1301
1302 def __str__(self):
1303 return '%s.%s' % (self.simobj, self.name)
1304
1305 # for config.ini, print peer's name (not ours)
1306 def ini_str(self):
1307 return str(self.peer)
1308
1309 def __getattr__(self, attr):
1310 if attr == 'peerObj':
1311 # shorthand for proxies
1312 return self.peer.simobj
1313 raise AttributeError, "'%s' object has no attribute '%s'" % \
1314 (self.__class__.__name__, attr)
1315
1316 # Full connection is symmetric (both ways). Called via
1317 # SimObject.__setattr__ as a result of a port assignment, e.g.,
1318 # "obj1.portA = obj2.portB", or via VectorPortElementRef.__setitem__,
1319 # e.g., "obj1.portA[3] = obj2.portB".
1320 def connect(self, other):
1321 if isinstance(other, VectorPortRef):
1322 # reference to plain VectorPort is implicit append
1323 other = other._get_next()
1324 if self.peer and not proxy.isproxy(self.peer):
1325 print "warning: overwriting port", self, \
1326 "value", self.peer, "with", other
1327 self.peer.peer = None
1328 self.peer = other
1329 if proxy.isproxy(other):
1330 other.set_param_desc(PortParamDesc())
1331 elif isinstance(other, PortRef):
1332 if other.peer is not self:
1333 other.connect(self)
1334 else:
1335 raise TypeError, \
1336 "assigning non-port reference '%s' to port '%s'" \
1337 % (other, self)
1338
1339 def clone(self, simobj, memo):
1340 if memo.has_key(self):
1341 return memo[self]
1342 newRef = copy.copy(self)
1343 memo[self] = newRef
1344 newRef.simobj = simobj
1345 assert(isSimObject(newRef.simobj))
1346 if self.peer and not proxy.isproxy(self.peer):
1347 peerObj = self.peer.simobj(_memo=memo)
1348 newRef.peer = self.peer.clone(peerObj, memo)
1349 assert(not isinstance(newRef.peer, VectorPortRef))
1350 return newRef
1351
1352 def unproxy(self, simobj):
1353 assert(simobj is self.simobj)
1354 if proxy.isproxy(self.peer):
1355 try:
1356 realPeer = self.peer.unproxy(self.simobj)
1357 except:
1358 print "Error in unproxying port '%s' of %s" % \
1359 (self.name, self.simobj.path())
1360 raise
1361 self.connect(realPeer)
1362
1363 # Call C++ to create corresponding port connection between C++ objects
1364 def ccConnect(self):
1365 from m5.internal.params import connectPorts
1366
1367 if self.ccConnected: # already done this
1368 return
1369 peer = self.peer
1370 if not self.peer: # nothing to connect to
1371 return
1372 try:
1373 connectPorts(self.simobj.getCCObject(), self.name, self.index,
1374 peer.simobj.getCCObject(), peer.name, peer.index)
1375 except:
1376 print "Error connecting port %s.%s to %s.%s" % \
1377 (self.simobj.path(), self.name,
1378 peer.simobj.path(), peer.name)
1379 raise
1380 self.ccConnected = True
1381 peer.ccConnected = True
1382
1383# A reference to an individual element of a VectorPort... much like a
1384# PortRef, but has an index.
1385class VectorPortElementRef(PortRef):
1386 def __init__(self, simobj, name, index):
1387 PortRef.__init__(self, simobj, name)
1388 self.index = index
1389
1390 def __str__(self):
1391 return '%s.%s[%d]' % (self.simobj, self.name, self.index)
1392
1393# A reference to a complete vector-valued port (not just a single element).
1394# Can be indexed to retrieve individual VectorPortElementRef instances.
1395class VectorPortRef(object):
1396 def __init__(self, simobj, name):
1397 assert(isSimObject(simobj) or isSimObjectClass(simobj))
1398 self.simobj = simobj
1399 self.name = name
1400 self.elements = []
1401
1402 def __str__(self):
1403 return '%s.%s[:]' % (self.simobj, self.name)
1404
1405 # for config.ini, print peer's name (not ours)
1406 def ini_str(self):
1407 return ' '.join([el.ini_str() for el in self.elements])
1408
1409 def __getitem__(self, key):
1410 if not isinstance(key, int):
1411 raise TypeError, "VectorPort index must be integer"
1412 if key >= len(self.elements):
1413 # need to extend list
1414 ext = [VectorPortElementRef(self.simobj, self.name, i)
1415 for i in range(len(self.elements), key+1)]
1416 self.elements.extend(ext)
1417 return self.elements[key]
1418
1419 def _get_next(self):
1420 return self[len(self.elements)]
1421
1422 def __setitem__(self, key, value):
1423 if not isinstance(key, int):
1424 raise TypeError, "VectorPort index must be integer"
1425 self[key].connect(value)
1426
1427 def connect(self, other):
1428 if isinstance(other, (list, tuple)):
1429 # Assign list of port refs to vector port.
1430 # For now, append them... not sure if that's the right semantics
1431 # or if it should replace the current vector.
1432 for ref in other:
1433 self._get_next().connect(ref)
1434 else:
1435 # scalar assignment to plain VectorPort is implicit append
1436 self._get_next().connect(other)
1437
1438 def clone(self, simobj, memo):
1439 if memo.has_key(self):
1440 return memo[self]
1441 newRef = copy.copy(self)
1442 memo[self] = newRef
1443 newRef.simobj = simobj
1444 assert(isSimObject(newRef.simobj))
1445 newRef.elements = [el.clone(simobj, memo) for el in self.elements]
1446 return newRef
1447
1448 def unproxy(self, simobj):
1449 [el.unproxy(simobj) for el in self.elements]
1450
1451 def ccConnect(self):
1452 [el.ccConnect() for el in self.elements]
1453
1454# Port description object. Like a ParamDesc object, this represents a
1455# logical port in the SimObject class, not a particular port on a
1456# SimObject instance. The latter are represented by PortRef objects.
1457class Port(object):
1458 # Port("description") or Port(default, "description")
1459 def __init__(self, *args):
1460 if len(args) == 1:
1461 self.desc = args[0]
1462 elif len(args) == 2:
1463 self.default = args[0]
1464 self.desc = args[1]
1465 else:
1466 raise TypeError, 'wrong number of arguments'
1467 # self.name is set by SimObject class on assignment
1468 # e.g., pio_port = Port("blah") sets self.name to 'pio_port'
1469
1470 # Generate a PortRef for this port on the given SimObject with the
1471 # given name
1472 def makeRef(self, simobj):
1473 return PortRef(simobj, self.name)
1474
1475 # Connect an instance of this port (on the given SimObject with
1476 # the given name) with the port described by the supplied PortRef
1477 def connect(self, simobj, ref):
1478 self.makeRef(simobj).connect(ref)
1479
1480# VectorPort description object. Like Port, but represents a vector
1481# of connections (e.g., as on a Bus).
1482class VectorPort(Port):
1483 def __init__(self, *args):
1484 Port.__init__(self, *args)
1485 self.isVec = True
1486
1487 def makeRef(self, simobj):
1488 return VectorPortRef(simobj, self.name)
1489
1490# 'Fake' ParamDesc for Port references to assign to the _pdesc slot of
1491# proxy objects (via set_param_desc()) so that proxy error messages
1492# make sense.
1493class PortParamDesc(object):
1494 __metaclass__ = Singleton
1495
1496 ptype_str = 'Port'
1497 ptype = Port
1498
1499baseEnums = allEnums.copy()
1500baseParams = allParams.copy()
1501
1502def clear():
1503 global allEnums, allParams
1504
1505 allEnums = baseEnums.copy()
1506 allParams = baseParams.copy()
1507
1508__all__ = ['Param', 'VectorParam',
1509 'Enum', 'Bool', 'String', 'Float',
1510 'Int', 'Unsigned', 'Int8', 'UInt8', 'Int16', 'UInt16',
1511 'Int32', 'UInt32', 'Int64', 'UInt64',
1512 'Counter', 'Addr', 'Tick', 'Percent',
1513 'TcpPort', 'UdpPort', 'EthernetAddr',
1514 'IpAddress', 'IpNetmask', 'IpWithPort',
1515 'MemorySize', 'MemorySize32',
1516 'Latency', 'Frequency', 'Clock',
1517 'NetworkBandwidth', 'MemoryBandwidth',
1518 'Range', 'AddrRange', 'TickRange',
1519 'MaxAddr', 'MaxTick', 'AllMemory',
1520 'Time',
1521 'NextEthernetAddr', 'NULL',
1522 'Port', 'VectorPort']
1523
1524import SimObject