params.py revision 8579
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 1525