params.py revision 12193:ae90e2b82531
1# Copyright (c) 2012-2014, 2017 ARM Limited 2# All rights reserved. 3# 4# The license below extends only to copyright in the software and shall 5# not be construed as granting a license to any other intellectual 6# property including but not limited to intellectual property relating 7# to a hardware implementation of the functionality of the software 8# licensed hereunder. You may use the software subject to the license 9# terms below provided that you ensure that this notice is replicated 10# unmodified and in its entirety in all distributions of the software, 11# modified or unmodified, in source code or in binary form. 12# 13# Copyright (c) 2004-2006 The Regents of The University of Michigan 14# Copyright (c) 2010-2011 Advanced Micro Devices, Inc. 15# All rights reserved. 16# 17# Redistribution and use in source and binary forms, with or without 18# modification, are permitted provided that the following conditions are 19# met: redistributions of source code must retain the above copyright 20# notice, this list of conditions and the following disclaimer; 21# redistributions in binary form must reproduce the above copyright 22# notice, this list of conditions and the following disclaimer in the 23# documentation and/or other materials provided with the distribution; 24# neither the name of the copyright holders nor the names of its 25# contributors may be used to endorse or promote products derived from 26# this software without specific prior written permission. 27# 28# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 29# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 30# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 31# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 32# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 33# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 34# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 35# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 36# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 37# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 38# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 39# 40# Authors: Steve Reinhardt 41# Nathan Binkert 42# Gabe Black 43# Andreas Hansson 44 45##################################################################### 46# 47# Parameter description classes 48# 49# The _params dictionary in each class maps parameter names to either 50# a Param or a VectorParam object. These objects contain the 51# parameter description string, the parameter type, and the default 52# value (if any). The convert() method on these objects is used to 53# force whatever value is assigned to the parameter to the appropriate 54# type. 55# 56# Note that the default values are loaded into the class's attribute 57# space when the parameter dictionary is initialized (in 58# MetaSimObject._new_param()); after that point they aren't used. 59# 60##################################################################### 61 62import copy 63import datetime 64import re 65import sys 66import time 67import math 68 69import proxy 70import ticks 71from util import * 72 73def isSimObject(*args, **kwargs): 74 return SimObject.isSimObject(*args, **kwargs) 75 76def isSimObjectSequence(*args, **kwargs): 77 return SimObject.isSimObjectSequence(*args, **kwargs) 78 79def isSimObjectClass(*args, **kwargs): 80 return SimObject.isSimObjectClass(*args, **kwargs) 81 82allParams = {} 83 84class MetaParamValue(type): 85 def __new__(mcls, name, bases, dct): 86 cls = super(MetaParamValue, mcls).__new__(mcls, name, bases, dct) 87 assert name not in allParams 88 allParams[name] = cls 89 return cls 90 91 92# Dummy base class to identify types that are legitimate for SimObject 93# parameters. 94class ParamValue(object): 95 __metaclass__ = MetaParamValue 96 cmd_line_settable = False 97 98 # Generate the code needed as a prerequisite for declaring a C++ 99 # object of this type. Typically generates one or more #include 100 # statements. Used when declaring parameters of this type. 101 @classmethod 102 def cxx_predecls(cls, code): 103 pass 104 105 @classmethod 106 def pybind_predecls(cls, code): 107 cls.cxx_predecls(code) 108 109 # default for printing to .ini file is regular string conversion. 110 # will be overridden in some cases 111 def ini_str(self): 112 return str(self) 113 114 # default for printing to .json file is regular string conversion. 115 # will be overridden in some cases, mostly to use native Python 116 # types where there are similar JSON types 117 def config_value(self): 118 return str(self) 119 120 # Prerequisites for .ini parsing with cxx_ini_parse 121 @classmethod 122 def cxx_ini_predecls(cls, code): 123 pass 124 125 # parse a .ini file entry for this param from string expression 126 # src into lvalue dest (of the param's C++ type) 127 @classmethod 128 def cxx_ini_parse(cls, code, src, dest, ret): 129 code('// Unhandled param type: %s' % cls.__name__) 130 code('%s false;' % ret) 131 132 # allows us to blithely call unproxy() on things without checking 133 # if they're really proxies or not 134 def unproxy(self, base): 135 return self 136 137 # Produce a human readable version of the stored value 138 def pretty_print(self, value): 139 return str(value) 140 141# Regular parameter description. 142class ParamDesc(object): 143 def __init__(self, ptype_str, ptype, *args, **kwargs): 144 self.ptype_str = ptype_str 145 # remember ptype only if it is provided 146 if ptype != None: 147 self.ptype = ptype 148 149 if args: 150 if len(args) == 1: 151 self.desc = args[0] 152 elif len(args) == 2: 153 self.default = args[0] 154 self.desc = args[1] 155 else: 156 raise TypeError, 'too many arguments' 157 158 if kwargs.has_key('desc'): 159 assert(not hasattr(self, 'desc')) 160 self.desc = kwargs['desc'] 161 del kwargs['desc'] 162 163 if kwargs.has_key('default'): 164 assert(not hasattr(self, 'default')) 165 self.default = kwargs['default'] 166 del kwargs['default'] 167 168 if kwargs: 169 raise TypeError, 'extra unknown kwargs %s' % kwargs 170 171 if not hasattr(self, 'desc'): 172 raise TypeError, 'desc attribute missing' 173 174 def __getattr__(self, attr): 175 if attr == 'ptype': 176 ptype = SimObject.allClasses[self.ptype_str] 177 assert isSimObjectClass(ptype) 178 self.ptype = ptype 179 return ptype 180 181 raise AttributeError, "'%s' object has no attribute '%s'" % \ 182 (type(self).__name__, attr) 183 184 def example_str(self): 185 if hasattr(self.ptype, "ex_str"): 186 return self.ptype.ex_str 187 else: 188 return self.ptype_str 189 190 # Is the param available to be exposed on the command line 191 def isCmdLineSettable(self): 192 if hasattr(self.ptype, "cmd_line_settable"): 193 return self.ptype.cmd_line_settable 194 else: 195 return False 196 197 def convert(self, value): 198 if isinstance(value, proxy.BaseProxy): 199 value.set_param_desc(self) 200 return value 201 if not hasattr(self, 'ptype') and isNullPointer(value): 202 # deferred evaluation of SimObject; continue to defer if 203 # we're just assigning a null pointer 204 return value 205 if isinstance(value, self.ptype): 206 return value 207 if isNullPointer(value) and isSimObjectClass(self.ptype): 208 return value 209 return self.ptype(value) 210 211 def pretty_print(self, value): 212 if isinstance(value, proxy.BaseProxy): 213 return str(value) 214 if isNullPointer(value): 215 return NULL 216 return self.ptype(value).pretty_print(value) 217 218 def cxx_predecls(self, code): 219 code('#include <cstddef>') 220 self.ptype.cxx_predecls(code) 221 222 def pybind_predecls(self, code): 223 self.ptype.pybind_predecls(code) 224 225 def cxx_decl(self, code): 226 code('${{self.ptype.cxx_type}} ${{self.name}};') 227 228# Vector-valued parameter description. Just like ParamDesc, except 229# that the value is a vector (list) of the specified type instead of a 230# single value. 231 232class VectorParamValue(list): 233 __metaclass__ = MetaParamValue 234 def __setattr__(self, attr, value): 235 raise AttributeError, \ 236 "Not allowed to set %s on '%s'" % (attr, type(self).__name__) 237 238 def config_value(self): 239 return [v.config_value() for v in self] 240 241 def ini_str(self): 242 return ' '.join([v.ini_str() for v in self]) 243 244 def getValue(self): 245 return [ v.getValue() for v in self ] 246 247 def unproxy(self, base): 248 if len(self) == 1 and isinstance(self[0], proxy.BaseProxy): 249 # The value is a proxy (e.g. Parent.any, Parent.all or 250 # Parent.x) therefore try resolve it 251 return self[0].unproxy(base) 252 else: 253 return [v.unproxy(base) for v in self] 254 255class SimObjectVector(VectorParamValue): 256 # support clone operation 257 def __call__(self, **kwargs): 258 return SimObjectVector([v(**kwargs) for v in self]) 259 260 def clear_parent(self, old_parent): 261 for v in self: 262 v.clear_parent(old_parent) 263 264 def set_parent(self, parent, name): 265 if len(self) == 1: 266 self[0].set_parent(parent, name) 267 else: 268 width = int(math.ceil(math.log(len(self))/math.log(10))) 269 for i,v in enumerate(self): 270 v.set_parent(parent, "%s%0*d" % (name, width, i)) 271 272 def has_parent(self): 273 elements = [e for e in self if not isNullPointer(e)] 274 return reduce(lambda x,y: x and y, [v.has_parent() for v in elements]) 275 276 # return 'cpu0 cpu1' etc. for print_ini() 277 def get_name(self): 278 return ' '.join([v._name for v in self]) 279 280 # By iterating through the constituent members of the vector here 281 # we can nicely handle iterating over all a SimObject's children 282 # without having to provide lots of special functions on 283 # SimObjectVector directly. 284 def descendants(self): 285 for v in self: 286 for obj in v.descendants(): 287 yield obj 288 289 def get_config_as_dict(self): 290 a = [] 291 for v in self: 292 a.append(v.get_config_as_dict()) 293 return a 294 295 # If we are replacing an item in the vector, make sure to set the 296 # parent reference of the new SimObject to be the same as the parent 297 # of the SimObject being replaced. Useful to have if we created 298 # a SimObjectVector of temporary objects that will be modified later in 299 # configuration scripts. 300 def __setitem__(self, key, value): 301 val = self[key] 302 if value.has_parent(): 303 warn("SimObject %s already has a parent" % value.get_name() +\ 304 " that is being overwritten by a SimObjectVector") 305 value.set_parent(val.get_parent(), val._name) 306 super(SimObjectVector, self).__setitem__(key, value) 307 308 # Enumerate the params of each member of the SimObject vector. Creates 309 # strings that will allow indexing into the vector by the python code and 310 # allow it to be specified on the command line. 311 def enumerateParams(self, flags_dict = {}, 312 cmd_line_str = "", 313 access_str = ""): 314 if hasattr(self, "_paramEnumed"): 315 print "Cycle detected enumerating params at %s?!" % (cmd_line_str) 316 else: 317 x = 0 318 for vals in self: 319 # Each entry in the SimObjectVector should be an 320 # instance of a SimObject 321 flags_dict = vals.enumerateParams(flags_dict, 322 cmd_line_str + "%d." % x, 323 access_str + "[%d]." % x) 324 x = x + 1 325 326 return flags_dict 327 328class VectorParamDesc(ParamDesc): 329 # Convert assigned value to appropriate type. If the RHS is not a 330 # list or tuple, it generates a single-element list. 331 def convert(self, value): 332 if isinstance(value, (list, tuple)): 333 # list: coerce each element into new list 334 tmp_list = [ ParamDesc.convert(self, v) for v in value ] 335 elif isinstance(value, str): 336 # If input is a csv string 337 tmp_list = [ ParamDesc.convert(self, v) \ 338 for v in value.strip('[').strip(']').split(',') ] 339 else: 340 # singleton: coerce to a single-element list 341 tmp_list = [ ParamDesc.convert(self, value) ] 342 343 if isSimObjectSequence(tmp_list): 344 return SimObjectVector(tmp_list) 345 else: 346 return VectorParamValue(tmp_list) 347 348 # Produce a human readable example string that describes 349 # how to set this vector parameter in the absence of a default 350 # value. 351 def example_str(self): 352 s = super(VectorParamDesc, self).example_str() 353 help_str = "[" + s + "," + s + ", ...]" 354 return help_str 355 356 # Produce a human readable representation of the value of this vector param. 357 def pretty_print(self, value): 358 if isinstance(value, (list, tuple)): 359 tmp_list = [ ParamDesc.pretty_print(self, v) for v in value ] 360 elif isinstance(value, str): 361 tmp_list = [ ParamDesc.pretty_print(self, v) for v in value.split(',') ] 362 else: 363 tmp_list = [ ParamDesc.pretty_print(self, value) ] 364 365 return tmp_list 366 367 # This is a helper function for the new config system 368 def __call__(self, value): 369 if isinstance(value, (list, tuple)): 370 # list: coerce each element into new list 371 tmp_list = [ ParamDesc.convert(self, v) for v in value ] 372 elif isinstance(value, str): 373 # If input is a csv string 374 tmp_list = [ ParamDesc.convert(self, v) \ 375 for v in value.strip('[').strip(']').split(',') ] 376 else: 377 # singleton: coerce to a single-element list 378 tmp_list = [ ParamDesc.convert(self, value) ] 379 380 return VectorParamValue(tmp_list) 381 382 def cxx_predecls(self, code): 383 code('#include <vector>') 384 self.ptype.cxx_predecls(code) 385 386 def pybind_predecls(self, code): 387 code('#include <vector>') 388 self.ptype.pybind_predecls(code) 389 390 def cxx_decl(self, code): 391 code('std::vector< ${{self.ptype.cxx_type}} > ${{self.name}};') 392 393class ParamFactory(object): 394 def __init__(self, param_desc_class, ptype_str = None): 395 self.param_desc_class = param_desc_class 396 self.ptype_str = ptype_str 397 398 def __getattr__(self, attr): 399 if self.ptype_str: 400 attr = self.ptype_str + '.' + attr 401 return ParamFactory(self.param_desc_class, attr) 402 403 # E.g., Param.Int(5, "number of widgets") 404 def __call__(self, *args, **kwargs): 405 ptype = None 406 try: 407 ptype = allParams[self.ptype_str] 408 except KeyError: 409 # if name isn't defined yet, assume it's a SimObject, and 410 # try to resolve it later 411 pass 412 return self.param_desc_class(self.ptype_str, ptype, *args, **kwargs) 413 414Param = ParamFactory(ParamDesc) 415VectorParam = ParamFactory(VectorParamDesc) 416 417##################################################################### 418# 419# Parameter Types 420# 421# Though native Python types could be used to specify parameter types 422# (the 'ptype' field of the Param and VectorParam classes), it's more 423# flexible to define our own set of types. This gives us more control 424# over how Python expressions are converted to values (via the 425# __init__() constructor) and how these values are printed out (via 426# the __str__() conversion method). 427# 428##################################################################### 429 430# String-valued parameter. Just mixin the ParamValue class with the 431# built-in str class. 432class String(ParamValue,str): 433 cxx_type = 'std::string' 434 cmd_line_settable = True 435 436 @classmethod 437 def cxx_predecls(self, code): 438 code('#include <string>') 439 440 def __call__(self, value): 441 self = value 442 return value 443 444 @classmethod 445 def cxx_ini_parse(self, code, src, dest, ret): 446 code('%s = %s;' % (dest, src)) 447 code('%s true;' % ret) 448 449 def getValue(self): 450 return self 451 452# superclass for "numeric" parameter values, to emulate math 453# operations in a type-safe way. e.g., a Latency times an int returns 454# a new Latency object. 455class NumericParamValue(ParamValue): 456 def __str__(self): 457 return str(self.value) 458 459 def __float__(self): 460 return float(self.value) 461 462 def __long__(self): 463 return long(self.value) 464 465 def __int__(self): 466 return int(self.value) 467 468 # hook for bounds checking 469 def _check(self): 470 return 471 472 def __mul__(self, other): 473 newobj = self.__class__(self) 474 newobj.value *= other 475 newobj._check() 476 return newobj 477 478 __rmul__ = __mul__ 479 480 def __div__(self, other): 481 newobj = self.__class__(self) 482 newobj.value /= other 483 newobj._check() 484 return newobj 485 486 def __sub__(self, other): 487 newobj = self.__class__(self) 488 newobj.value -= other 489 newobj._check() 490 return newobj 491 492 def config_value(self): 493 return self.value 494 495 @classmethod 496 def cxx_ini_predecls(cls, code): 497 # Assume that base/str.hh will be included anyway 498 # code('#include "base/str.hh"') 499 pass 500 501 # The default for parsing PODs from an .ini entry is to extract from an 502 # istringstream and let overloading choose the right type according to 503 # the dest type. 504 @classmethod 505 def cxx_ini_parse(self, code, src, dest, ret): 506 code('%s to_number(%s, %s);' % (ret, src, dest)) 507 508# Metaclass for bounds-checked integer parameters. See CheckedInt. 509class CheckedIntType(MetaParamValue): 510 def __init__(cls, name, bases, dict): 511 super(CheckedIntType, cls).__init__(name, bases, dict) 512 513 # CheckedInt is an abstract base class, so we actually don't 514 # want to do any processing on it... the rest of this code is 515 # just for classes that derive from CheckedInt. 516 if name == 'CheckedInt': 517 return 518 519 if not (hasattr(cls, 'min') and hasattr(cls, 'max')): 520 if not (hasattr(cls, 'size') and hasattr(cls, 'unsigned')): 521 panic("CheckedInt subclass %s must define either\n" \ 522 " 'min' and 'max' or 'size' and 'unsigned'\n", 523 name); 524 if cls.unsigned: 525 cls.min = 0 526 cls.max = 2 ** cls.size - 1 527 else: 528 cls.min = -(2 ** (cls.size - 1)) 529 cls.max = (2 ** (cls.size - 1)) - 1 530 531# Abstract superclass for bounds-checked integer parameters. This 532# class is subclassed to generate parameter classes with specific 533# bounds. Initialization of the min and max bounds is done in the 534# metaclass CheckedIntType.__init__. 535class CheckedInt(NumericParamValue): 536 __metaclass__ = CheckedIntType 537 cmd_line_settable = True 538 539 def _check(self): 540 if not self.min <= self.value <= self.max: 541 raise TypeError, 'Integer param out of bounds %d < %d < %d' % \ 542 (self.min, self.value, self.max) 543 544 def __init__(self, value): 545 if isinstance(value, str): 546 self.value = convert.toInteger(value) 547 elif isinstance(value, (int, long, float, NumericParamValue)): 548 self.value = long(value) 549 else: 550 raise TypeError, "Can't convert object of type %s to CheckedInt" \ 551 % type(value).__name__ 552 self._check() 553 554 def __call__(self, value): 555 self.__init__(value) 556 return value 557 558 @classmethod 559 def cxx_predecls(cls, code): 560 # most derived types require this, so we just do it here once 561 code('#include "base/types.hh"') 562 563 def getValue(self): 564 return long(self.value) 565 566class Int(CheckedInt): cxx_type = 'int'; size = 32; unsigned = False 567class Unsigned(CheckedInt): cxx_type = 'unsigned'; size = 32; unsigned = True 568 569class Int8(CheckedInt): cxx_type = 'int8_t'; size = 8; unsigned = False 570class UInt8(CheckedInt): cxx_type = 'uint8_t'; size = 8; unsigned = True 571class Int16(CheckedInt): cxx_type = 'int16_t'; size = 16; unsigned = False 572class UInt16(CheckedInt): cxx_type = 'uint16_t'; size = 16; unsigned = True 573class Int32(CheckedInt): cxx_type = 'int32_t'; size = 32; unsigned = False 574class UInt32(CheckedInt): cxx_type = 'uint32_t'; size = 32; unsigned = True 575class Int64(CheckedInt): cxx_type = 'int64_t'; size = 64; unsigned = False 576class UInt64(CheckedInt): cxx_type = 'uint64_t'; size = 64; unsigned = True 577 578class Counter(CheckedInt): cxx_type = 'Counter'; size = 64; unsigned = True 579class Tick(CheckedInt): cxx_type = 'Tick'; size = 64; unsigned = True 580class TcpPort(CheckedInt): cxx_type = 'uint16_t'; size = 16; unsigned = True 581class UdpPort(CheckedInt): cxx_type = 'uint16_t'; size = 16; unsigned = True 582 583class Percent(CheckedInt): cxx_type = 'int'; min = 0; max = 100 584 585class Cycles(CheckedInt): 586 cxx_type = 'Cycles' 587 size = 64 588 unsigned = True 589 590 def getValue(self): 591 from _m5.core import Cycles 592 return Cycles(self.value) 593 594 @classmethod 595 def cxx_ini_predecls(cls, code): 596 # Assume that base/str.hh will be included anyway 597 # code('#include "base/str.hh"') 598 pass 599 600 @classmethod 601 def cxx_ini_parse(cls, code, src, dest, ret): 602 code('uint64_t _temp;') 603 code('bool _ret = to_number(%s, _temp);' % src) 604 code('if (_ret)') 605 code(' %s = Cycles(_temp);' % dest) 606 code('%s _ret;' % ret) 607 608class Float(ParamValue, float): 609 cxx_type = 'double' 610 cmd_line_settable = True 611 612 def __init__(self, value): 613 if isinstance(value, (int, long, float, NumericParamValue, Float, str)): 614 self.value = float(value) 615 else: 616 raise TypeError, "Can't convert object of type %s to Float" \ 617 % type(value).__name__ 618 619 def __call__(self, value): 620 self.__init__(value) 621 return value 622 623 def getValue(self): 624 return float(self.value) 625 626 def config_value(self): 627 return self 628 629 @classmethod 630 def cxx_ini_predecls(cls, code): 631 code('#include <sstream>') 632 633 @classmethod 634 def cxx_ini_parse(self, code, src, dest, ret): 635 code('%s (std::istringstream(%s) >> %s).eof();' % (ret, src, dest)) 636 637class MemorySize(CheckedInt): 638 cxx_type = 'uint64_t' 639 ex_str = '512MB' 640 size = 64 641 unsigned = True 642 def __init__(self, value): 643 if isinstance(value, MemorySize): 644 self.value = value.value 645 else: 646 self.value = convert.toMemorySize(value) 647 self._check() 648 649class MemorySize32(CheckedInt): 650 cxx_type = 'uint32_t' 651 ex_str = '512MB' 652 size = 32 653 unsigned = True 654 def __init__(self, value): 655 if isinstance(value, MemorySize): 656 self.value = value.value 657 else: 658 self.value = convert.toMemorySize(value) 659 self._check() 660 661class Addr(CheckedInt): 662 cxx_type = 'Addr' 663 size = 64 664 unsigned = True 665 def __init__(self, value): 666 if isinstance(value, Addr): 667 self.value = value.value 668 else: 669 try: 670 # Often addresses are referred to with sizes. Ex: A device 671 # base address is at "512MB". Use toMemorySize() to convert 672 # these into addresses. If the address is not specified with a 673 # "size", an exception will occur and numeric translation will 674 # proceed below. 675 self.value = convert.toMemorySize(value) 676 except (TypeError, ValueError): 677 # Convert number to string and use long() to do automatic 678 # base conversion (requires base=0 for auto-conversion) 679 self.value = long(str(value), base=0) 680 681 self._check() 682 def __add__(self, other): 683 if isinstance(other, Addr): 684 return self.value + other.value 685 else: 686 return self.value + other 687 def pretty_print(self, value): 688 try: 689 val = convert.toMemorySize(value) 690 except TypeError: 691 val = long(value) 692 return "0x%x" % long(val) 693 694class AddrRange(ParamValue): 695 cxx_type = 'AddrRange' 696 697 def __init__(self, *args, **kwargs): 698 # Disable interleaving and hashing by default 699 self.intlvHighBit = 0 700 self.xorHighBit = 0 701 self.intlvBits = 0 702 self.intlvMatch = 0 703 704 def handle_kwargs(self, kwargs): 705 # An address range needs to have an upper limit, specified 706 # either explicitly with an end, or as an offset using the 707 # size keyword. 708 if 'end' in kwargs: 709 self.end = Addr(kwargs.pop('end')) 710 elif 'size' in kwargs: 711 self.end = self.start + Addr(kwargs.pop('size')) - 1 712 else: 713 raise TypeError, "Either end or size must be specified" 714 715 # Now on to the optional bit 716 if 'intlvHighBit' in kwargs: 717 self.intlvHighBit = int(kwargs.pop('intlvHighBit')) 718 if 'xorHighBit' in kwargs: 719 self.xorHighBit = int(kwargs.pop('xorHighBit')) 720 if 'intlvBits' in kwargs: 721 self.intlvBits = int(kwargs.pop('intlvBits')) 722 if 'intlvMatch' in kwargs: 723 self.intlvMatch = int(kwargs.pop('intlvMatch')) 724 725 if len(args) == 0: 726 self.start = Addr(kwargs.pop('start')) 727 handle_kwargs(self, kwargs) 728 729 elif len(args) == 1: 730 if kwargs: 731 self.start = Addr(args[0]) 732 handle_kwargs(self, kwargs) 733 elif isinstance(args[0], (list, tuple)): 734 self.start = Addr(args[0][0]) 735 self.end = Addr(args[0][1]) 736 else: 737 self.start = Addr(0) 738 self.end = Addr(args[0]) - 1 739 740 elif len(args) == 2: 741 self.start = Addr(args[0]) 742 self.end = Addr(args[1]) 743 else: 744 raise TypeError, "Too many arguments specified" 745 746 if kwargs: 747 raise TypeError, "Too many keywords: %s" % kwargs.keys() 748 749 def __str__(self): 750 return '%s:%s:%s:%s:%s:%s' \ 751 % (self.start, self.end, self.intlvHighBit, self.xorHighBit,\ 752 self.intlvBits, self.intlvMatch) 753 754 def size(self): 755 # Divide the size by the size of the interleaving slice 756 return (long(self.end) - long(self.start) + 1) >> self.intlvBits 757 758 @classmethod 759 def cxx_predecls(cls, code): 760 Addr.cxx_predecls(code) 761 code('#include "base/addr_range.hh"') 762 763 @classmethod 764 def pybind_predecls(cls, code): 765 Addr.pybind_predecls(code) 766 code('#include "base/addr_range.hh"') 767 768 @classmethod 769 def cxx_ini_predecls(cls, code): 770 code('#include <sstream>') 771 772 @classmethod 773 def cxx_ini_parse(cls, code, src, dest, ret): 774 code('uint64_t _start, _end, _intlvHighBit = 0, _xorHighBit = 0;') 775 code('uint64_t _intlvBits = 0, _intlvMatch = 0;') 776 code('char _sep;') 777 code('std::istringstream _stream(${src});') 778 code('_stream >> _start;') 779 code('_stream.get(_sep);') 780 code('_stream >> _end;') 781 code('if (!_stream.fail() && !_stream.eof()) {') 782 code(' _stream.get(_sep);') 783 code(' _stream >> _intlvHighBit;') 784 code(' _stream.get(_sep);') 785 code(' _stream >> _xorHighBit;') 786 code(' _stream.get(_sep);') 787 code(' _stream >> _intlvBits;') 788 code(' _stream.get(_sep);') 789 code(' _stream >> _intlvMatch;') 790 code('}') 791 code('bool _ret = !_stream.fail() &&' 792 '_stream.eof() && _sep == \':\';') 793 code('if (_ret)') 794 code(' ${dest} = AddrRange(_start, _end, _intlvHighBit, \ 795 _xorHighBit, _intlvBits, _intlvMatch);') 796 code('${ret} _ret;') 797 798 def getValue(self): 799 # Go from the Python class to the wrapped C++ class 800 from _m5.range import AddrRange 801 802 return AddrRange(long(self.start), long(self.end), 803 int(self.intlvHighBit), int(self.xorHighBit), 804 int(self.intlvBits), int(self.intlvMatch)) 805 806# Boolean parameter type. Python doesn't let you subclass bool, since 807# it doesn't want to let you create multiple instances of True and 808# False. Thus this is a little more complicated than String. 809class Bool(ParamValue): 810 cxx_type = 'bool' 811 cmd_line_settable = True 812 813 def __init__(self, value): 814 try: 815 self.value = convert.toBool(value) 816 except TypeError: 817 self.value = bool(value) 818 819 def __call__(self, value): 820 self.__init__(value) 821 return value 822 823 def getValue(self): 824 return bool(self.value) 825 826 def __str__(self): 827 return str(self.value) 828 829 # implement truth value testing for Bool parameters so that these params 830 # evaluate correctly during the python configuration phase 831 def __nonzero__(self): 832 return bool(self.value) 833 834 def ini_str(self): 835 if self.value: 836 return 'true' 837 return 'false' 838 839 def config_value(self): 840 return self.value 841 842 @classmethod 843 def cxx_ini_predecls(cls, code): 844 # Assume that base/str.hh will be included anyway 845 # code('#include "base/str.hh"') 846 pass 847 848 @classmethod 849 def cxx_ini_parse(cls, code, src, dest, ret): 850 code('%s to_bool(%s, %s);' % (ret, src, dest)) 851 852def IncEthernetAddr(addr, val = 1): 853 bytes = map(lambda x: int(x, 16), addr.split(':')) 854 bytes[5] += val 855 for i in (5, 4, 3, 2, 1): 856 val,rem = divmod(bytes[i], 256) 857 bytes[i] = rem 858 if val == 0: 859 break 860 bytes[i - 1] += val 861 assert(bytes[0] <= 255) 862 return ':'.join(map(lambda x: '%02x' % x, bytes)) 863 864_NextEthernetAddr = "00:90:00:00:00:01" 865def NextEthernetAddr(): 866 global _NextEthernetAddr 867 868 value = _NextEthernetAddr 869 _NextEthernetAddr = IncEthernetAddr(_NextEthernetAddr, 1) 870 return value 871 872class EthernetAddr(ParamValue): 873 cxx_type = 'Net::EthAddr' 874 ex_str = "00:90:00:00:00:01" 875 cmd_line_settable = True 876 877 @classmethod 878 def cxx_predecls(cls, code): 879 code('#include "base/inet.hh"') 880 881 def __init__(self, value): 882 if value == NextEthernetAddr: 883 self.value = value 884 return 885 886 if not isinstance(value, str): 887 raise TypeError, "expected an ethernet address and didn't get one" 888 889 bytes = value.split(':') 890 if len(bytes) != 6: 891 raise TypeError, 'invalid ethernet address %s' % value 892 893 for byte in bytes: 894 if not 0 <= int(byte, base=16) <= 0xff: 895 raise TypeError, 'invalid ethernet address %s' % value 896 897 self.value = value 898 899 def __call__(self, value): 900 self.__init__(value) 901 return value 902 903 def unproxy(self, base): 904 if self.value == NextEthernetAddr: 905 return EthernetAddr(self.value()) 906 return self 907 908 def getValue(self): 909 from _m5.net import EthAddr 910 return EthAddr(self.value) 911 912 def __str__(self): 913 return self.value 914 915 def ini_str(self): 916 return self.value 917 918 @classmethod 919 def cxx_ini_parse(self, code, src, dest, ret): 920 code('%s = Net::EthAddr(%s);' % (dest, src)) 921 code('%s true;' % ret) 922 923# When initializing an IpAddress, pass in an existing IpAddress, a string of 924# the form "a.b.c.d", or an integer representing an IP. 925class IpAddress(ParamValue): 926 cxx_type = 'Net::IpAddress' 927 ex_str = "127.0.0.1" 928 cmd_line_settable = True 929 930 @classmethod 931 def cxx_predecls(cls, code): 932 code('#include "base/inet.hh"') 933 934 def __init__(self, value): 935 if isinstance(value, IpAddress): 936 self.ip = value.ip 937 else: 938 try: 939 self.ip = convert.toIpAddress(value) 940 except TypeError: 941 self.ip = long(value) 942 self.verifyIp() 943 944 def __call__(self, value): 945 self.__init__(value) 946 return value 947 948 def __str__(self): 949 tup = [(self.ip >> i) & 0xff for i in (24, 16, 8, 0)] 950 return '%d.%d.%d.%d' % tuple(tup) 951 952 def __eq__(self, other): 953 if isinstance(other, IpAddress): 954 return self.ip == other.ip 955 elif isinstance(other, str): 956 try: 957 return self.ip == convert.toIpAddress(other) 958 except: 959 return False 960 else: 961 return self.ip == other 962 963 def __ne__(self, other): 964 return not (self == other) 965 966 def verifyIp(self): 967 if self.ip < 0 or self.ip >= (1 << 32): 968 raise TypeError, "invalid ip address %#08x" % self.ip 969 970 def getValue(self): 971 from _m5.net import IpAddress 972 return IpAddress(self.ip) 973 974# When initializing an IpNetmask, pass in an existing IpNetmask, a string of 975# the form "a.b.c.d/n" or "a.b.c.d/e.f.g.h", or an ip and netmask as 976# positional or keyword arguments. 977class IpNetmask(IpAddress): 978 cxx_type = 'Net::IpNetmask' 979 ex_str = "127.0.0.0/24" 980 cmd_line_settable = True 981 982 @classmethod 983 def cxx_predecls(cls, code): 984 code('#include "base/inet.hh"') 985 986 def __init__(self, *args, **kwargs): 987 def handle_kwarg(self, kwargs, key, elseVal = None): 988 if key in kwargs: 989 setattr(self, key, kwargs.pop(key)) 990 elif elseVal: 991 setattr(self, key, elseVal) 992 else: 993 raise TypeError, "No value set for %s" % key 994 995 if len(args) == 0: 996 handle_kwarg(self, kwargs, 'ip') 997 handle_kwarg(self, kwargs, 'netmask') 998 999 elif len(args) == 1: 1000 if kwargs: 1001 if not 'ip' in kwargs and not 'netmask' in kwargs: 1002 raise TypeError, "Invalid arguments" 1003 handle_kwarg(self, kwargs, 'ip', args[0]) 1004 handle_kwarg(self, kwargs, 'netmask', args[0]) 1005 elif isinstance(args[0], IpNetmask): 1006 self.ip = args[0].ip 1007 self.netmask = args[0].netmask 1008 else: 1009 (self.ip, self.netmask) = convert.toIpNetmask(args[0]) 1010 1011 elif len(args) == 2: 1012 self.ip = args[0] 1013 self.netmask = args[1] 1014 else: 1015 raise TypeError, "Too many arguments specified" 1016 1017 if kwargs: 1018 raise TypeError, "Too many keywords: %s" % kwargs.keys() 1019 1020 self.verify() 1021 1022 def __call__(self, value): 1023 self.__init__(value) 1024 return value 1025 1026 def __str__(self): 1027 return "%s/%d" % (super(IpNetmask, self).__str__(), self.netmask) 1028 1029 def __eq__(self, other): 1030 if isinstance(other, IpNetmask): 1031 return self.ip == other.ip and self.netmask == other.netmask 1032 elif isinstance(other, str): 1033 try: 1034 return (self.ip, self.netmask) == convert.toIpNetmask(other) 1035 except: 1036 return False 1037 else: 1038 return False 1039 1040 def verify(self): 1041 self.verifyIp() 1042 if self.netmask < 0 or self.netmask > 32: 1043 raise TypeError, "invalid netmask %d" % netmask 1044 1045 def getValue(self): 1046 from _m5.net import IpNetmask 1047 return IpNetmask(self.ip, self.netmask) 1048 1049# When initializing an IpWithPort, pass in an existing IpWithPort, a string of 1050# the form "a.b.c.d:p", or an ip and port as positional or keyword arguments. 1051class IpWithPort(IpAddress): 1052 cxx_type = 'Net::IpWithPort' 1053 ex_str = "127.0.0.1:80" 1054 cmd_line_settable = True 1055 1056 @classmethod 1057 def cxx_predecls(cls, code): 1058 code('#include "base/inet.hh"') 1059 1060 def __init__(self, *args, **kwargs): 1061 def handle_kwarg(self, kwargs, key, elseVal = None): 1062 if key in kwargs: 1063 setattr(self, key, kwargs.pop(key)) 1064 elif elseVal: 1065 setattr(self, key, elseVal) 1066 else: 1067 raise TypeError, "No value set for %s" % key 1068 1069 if len(args) == 0: 1070 handle_kwarg(self, kwargs, 'ip') 1071 handle_kwarg(self, kwargs, 'port') 1072 1073 elif len(args) == 1: 1074 if kwargs: 1075 if not 'ip' in kwargs and not 'port' in kwargs: 1076 raise TypeError, "Invalid arguments" 1077 handle_kwarg(self, kwargs, 'ip', args[0]) 1078 handle_kwarg(self, kwargs, 'port', args[0]) 1079 elif isinstance(args[0], IpWithPort): 1080 self.ip = args[0].ip 1081 self.port = args[0].port 1082 else: 1083 (self.ip, self.port) = convert.toIpWithPort(args[0]) 1084 1085 elif len(args) == 2: 1086 self.ip = args[0] 1087 self.port = args[1] 1088 else: 1089 raise TypeError, "Too many arguments specified" 1090 1091 if kwargs: 1092 raise TypeError, "Too many keywords: %s" % kwargs.keys() 1093 1094 self.verify() 1095 1096 def __call__(self, value): 1097 self.__init__(value) 1098 return value 1099 1100 def __str__(self): 1101 return "%s:%d" % (super(IpWithPort, self).__str__(), self.port) 1102 1103 def __eq__(self, other): 1104 if isinstance(other, IpWithPort): 1105 return self.ip == other.ip and self.port == other.port 1106 elif isinstance(other, str): 1107 try: 1108 return (self.ip, self.port) == convert.toIpWithPort(other) 1109 except: 1110 return False 1111 else: 1112 return False 1113 1114 def verify(self): 1115 self.verifyIp() 1116 if self.port < 0 or self.port > 0xffff: 1117 raise TypeError, "invalid port %d" % self.port 1118 1119 def getValue(self): 1120 from _m5.net import IpWithPort 1121 return IpWithPort(self.ip, self.port) 1122 1123time_formats = [ "%a %b %d %H:%M:%S %Z %Y", 1124 "%a %b %d %H:%M:%S %Y", 1125 "%Y/%m/%d %H:%M:%S", 1126 "%Y/%m/%d %H:%M", 1127 "%Y/%m/%d", 1128 "%m/%d/%Y %H:%M:%S", 1129 "%m/%d/%Y %H:%M", 1130 "%m/%d/%Y", 1131 "%m/%d/%y %H:%M:%S", 1132 "%m/%d/%y %H:%M", 1133 "%m/%d/%y"] 1134 1135 1136def parse_time(value): 1137 from time import gmtime, strptime, struct_time, time 1138 from datetime import datetime, date 1139 1140 if isinstance(value, struct_time): 1141 return value 1142 1143 if isinstance(value, (int, long)): 1144 return gmtime(value) 1145 1146 if isinstance(value, (datetime, date)): 1147 return value.timetuple() 1148 1149 if isinstance(value, str): 1150 if value in ('Now', 'Today'): 1151 return time.gmtime(time.time()) 1152 1153 for format in time_formats: 1154 try: 1155 return strptime(value, format) 1156 except ValueError: 1157 pass 1158 1159 raise ValueError, "Could not parse '%s' as a time" % value 1160 1161class Time(ParamValue): 1162 cxx_type = 'tm' 1163 1164 @classmethod 1165 def cxx_predecls(cls, code): 1166 code('#include <time.h>') 1167 1168 def __init__(self, value): 1169 self.value = parse_time(value) 1170 1171 def __call__(self, value): 1172 self.__init__(value) 1173 return value 1174 1175 def getValue(self): 1176 from _m5.core import tm 1177 import calendar 1178 1179 return tm.gmtime(calendar.timegm(self.value)) 1180 1181 def __str__(self): 1182 return time.asctime(self.value) 1183 1184 def ini_str(self): 1185 return str(self) 1186 1187 def get_config_as_dict(self): 1188 assert false 1189 return str(self) 1190 1191 @classmethod 1192 def cxx_ini_predecls(cls, code): 1193 code('#include <time.h>') 1194 1195 @classmethod 1196 def cxx_ini_parse(cls, code, src, dest, ret): 1197 code('char *_parse_ret = strptime((${src}).c_str(),') 1198 code(' "%a %b %d %H:%M:%S %Y", &(${dest}));') 1199 code('${ret} _parse_ret && *_parse_ret == \'\\0\';'); 1200 1201# Enumerated types are a little more complex. The user specifies the 1202# type as Enum(foo) where foo is either a list or dictionary of 1203# alternatives (typically strings, but not necessarily so). (In the 1204# long run, the integer value of the parameter will be the list index 1205# or the corresponding dictionary value. For now, since we only check 1206# that the alternative is valid and then spit it into a .ini file, 1207# there's not much point in using the dictionary.) 1208 1209# What Enum() must do is generate a new type encapsulating the 1210# provided list/dictionary so that specific values of the parameter 1211# can be instances of that type. We define two hidden internal 1212# classes (_ListEnum and _DictEnum) to serve as base classes, then 1213# derive the new type from the appropriate base class on the fly. 1214 1215allEnums = {} 1216# Metaclass for Enum types 1217class MetaEnum(MetaParamValue): 1218 def __new__(mcls, name, bases, dict): 1219 assert name not in allEnums 1220 1221 cls = super(MetaEnum, mcls).__new__(mcls, name, bases, dict) 1222 allEnums[name] = cls 1223 return cls 1224 1225 def __init__(cls, name, bases, init_dict): 1226 if init_dict.has_key('map'): 1227 if not isinstance(cls.map, dict): 1228 raise TypeError, "Enum-derived class attribute 'map' " \ 1229 "must be of type dict" 1230 # build list of value strings from map 1231 cls.vals = cls.map.keys() 1232 cls.vals.sort() 1233 elif init_dict.has_key('vals'): 1234 if not isinstance(cls.vals, list): 1235 raise TypeError, "Enum-derived class attribute 'vals' " \ 1236 "must be of type list" 1237 # build string->value map from vals sequence 1238 cls.map = {} 1239 for idx,val in enumerate(cls.vals): 1240 cls.map[val] = idx 1241 else: 1242 raise TypeError, "Enum-derived class must define "\ 1243 "attribute 'map' or 'vals'" 1244 1245 cls.cxx_type = 'Enums::%s' % name 1246 1247 super(MetaEnum, cls).__init__(name, bases, init_dict) 1248 1249 # Generate C++ class declaration for this enum type. 1250 # Note that we wrap the enum in a class/struct to act as a namespace, 1251 # so that the enum strings can be brief w/o worrying about collisions. 1252 def cxx_decl(cls, code): 1253 wrapper_name = cls.wrapper_name 1254 wrapper = 'struct' if cls.wrapper_is_struct else 'namespace' 1255 name = cls.__name__ if cls.enum_name is None else cls.enum_name 1256 idem_macro = '__ENUM__%s__%s__' % (wrapper_name, name) 1257 1258 code('''\ 1259#ifndef $idem_macro 1260#define $idem_macro 1261 1262$wrapper $wrapper_name { 1263 enum $name { 1264''') 1265 code.indent(2) 1266 for val in cls.vals: 1267 code('$val = ${{cls.map[val]}},') 1268 code('Num_$name = ${{len(cls.vals)}}') 1269 code.dedent(2) 1270 code(' };') 1271 1272 if cls.wrapper_is_struct: 1273 code(' static const char *${name}Strings[Num_${name}];') 1274 code('};') 1275 else: 1276 code('extern const char *${name}Strings[Num_${name}];') 1277 code('}') 1278 1279 code() 1280 code('#endif // $idem_macro') 1281 1282 def cxx_def(cls, code): 1283 wrapper_name = cls.wrapper_name 1284 file_name = cls.__name__ 1285 name = cls.__name__ if cls.enum_name is None else cls.enum_name 1286 1287 code('#include "enums/$file_name.hh"') 1288 if cls.wrapper_is_struct: 1289 code('const char *${wrapper_name}::${name}Strings' 1290 '[Num_${name}] =') 1291 else: 1292 code('namespace Enums {') 1293 code.indent(1) 1294 code(' const char *${name}Strings[Num_${name}] =') 1295 1296 code('{') 1297 code.indent(1) 1298 for val in cls.vals: 1299 code('"$val",') 1300 code.dedent(1) 1301 code('};') 1302 1303 if not cls.wrapper_is_struct: 1304 code('} // namespace $wrapper_name') 1305 code.dedent(1) 1306 1307 def pybind_def(cls, code): 1308 name = cls.__name__ 1309 wrapper_name = cls.wrapper_name 1310 enum_name = cls.__name__ if cls.enum_name is None else cls.enum_name 1311 1312 code('''#include "pybind11/pybind11.h" 1313#include "pybind11/stl.h" 1314 1315#include <sim/init.hh> 1316 1317namespace py = pybind11; 1318 1319static void 1320module_init(py::module &m_internal) 1321{ 1322 py::module m = m_internal.def_submodule("enum_${name}"); 1323 1324 py::enum_<${wrapper_name}::${enum_name}>(m, "enum_${name}") 1325''') 1326 1327 code.indent() 1328 code.indent() 1329 for val in cls.vals: 1330 code('.value("${val}", ${wrapper_name}::${val})') 1331 code('.value("Num_${name}", ${wrapper_name}::Num_${enum_name})') 1332 code('.export_values()') 1333 code(';') 1334 code.dedent() 1335 1336 code('}') 1337 code.dedent() 1338 code() 1339 code('static EmbeddedPyBind embed_enum("enum_${name}", module_init);') 1340 1341 1342# Base class for enum types. 1343class Enum(ParamValue): 1344 __metaclass__ = MetaEnum 1345 vals = [] 1346 cmd_line_settable = True 1347 1348 # The name of the wrapping namespace or struct 1349 wrapper_name = 'Enums' 1350 1351 # If true, the enum is wrapped in a struct rather than a namespace 1352 wrapper_is_struct = False 1353 1354 # If not None, use this as the enum name rather than this class name 1355 enum_name = None 1356 1357 def __init__(self, value): 1358 if value not in self.map: 1359 raise TypeError, "Enum param got bad value '%s' (not in %s)" \ 1360 % (value, self.vals) 1361 self.value = value 1362 1363 def __call__(self, value): 1364 self.__init__(value) 1365 return value 1366 1367 @classmethod 1368 def cxx_predecls(cls, code): 1369 code('#include "enums/$0.hh"', cls.__name__) 1370 1371 @classmethod 1372 def cxx_ini_parse(cls, code, src, dest, ret): 1373 code('if (false) {') 1374 for elem_name in cls.map.iterkeys(): 1375 code('} else if (%s == "%s") {' % (src, elem_name)) 1376 code.indent() 1377 code('%s = Enums::%s;' % (dest, elem_name)) 1378 code('%s true;' % ret) 1379 code.dedent() 1380 code('} else {') 1381 code(' %s false;' % ret) 1382 code('}') 1383 1384 def getValue(self): 1385 import m5.internal.params 1386 e = getattr(m5.internal.params, "enum_%s" % self.__class__.__name__) 1387 return e(self.map[self.value]) 1388 1389 def __str__(self): 1390 return self.value 1391 1392# how big does a rounding error need to be before we warn about it? 1393frequency_tolerance = 0.001 # 0.1% 1394 1395class TickParamValue(NumericParamValue): 1396 cxx_type = 'Tick' 1397 ex_str = "1MHz" 1398 cmd_line_settable = True 1399 1400 @classmethod 1401 def cxx_predecls(cls, code): 1402 code('#include "base/types.hh"') 1403 1404 def __call__(self, value): 1405 self.__init__(value) 1406 return value 1407 1408 def getValue(self): 1409 return long(self.value) 1410 1411 @classmethod 1412 def cxx_ini_predecls(cls, code): 1413 code('#include <sstream>') 1414 1415 # Ticks are expressed in seconds in JSON files and in plain 1416 # Ticks in .ini files. Switch based on a config flag 1417 @classmethod 1418 def cxx_ini_parse(self, code, src, dest, ret): 1419 code('${ret} to_number(${src}, ${dest});') 1420 1421class Latency(TickParamValue): 1422 ex_str = "100ns" 1423 1424 def __init__(self, value): 1425 if isinstance(value, (Latency, Clock)): 1426 self.ticks = value.ticks 1427 self.value = value.value 1428 elif isinstance(value, Frequency): 1429 self.ticks = value.ticks 1430 self.value = 1.0 / value.value 1431 elif value.endswith('t'): 1432 self.ticks = True 1433 self.value = int(value[:-1]) 1434 else: 1435 self.ticks = False 1436 self.value = convert.toLatency(value) 1437 1438 def __call__(self, value): 1439 self.__init__(value) 1440 return value 1441 1442 def __getattr__(self, attr): 1443 if attr in ('latency', 'period'): 1444 return self 1445 if attr == 'frequency': 1446 return Frequency(self) 1447 raise AttributeError, "Latency object has no attribute '%s'" % attr 1448 1449 def getValue(self): 1450 if self.ticks or self.value == 0: 1451 value = self.value 1452 else: 1453 value = ticks.fromSeconds(self.value) 1454 return long(value) 1455 1456 def config_value(self): 1457 return self.getValue() 1458 1459 # convert latency to ticks 1460 def ini_str(self): 1461 return '%d' % self.getValue() 1462 1463class Frequency(TickParamValue): 1464 ex_str = "1GHz" 1465 1466 def __init__(self, value): 1467 if isinstance(value, (Latency, Clock)): 1468 if value.value == 0: 1469 self.value = 0 1470 else: 1471 self.value = 1.0 / value.value 1472 self.ticks = value.ticks 1473 elif isinstance(value, Frequency): 1474 self.value = value.value 1475 self.ticks = value.ticks 1476 else: 1477 self.ticks = False 1478 self.value = convert.toFrequency(value) 1479 1480 def __call__(self, value): 1481 self.__init__(value) 1482 return value 1483 1484 def __getattr__(self, attr): 1485 if attr == 'frequency': 1486 return self 1487 if attr in ('latency', 'period'): 1488 return Latency(self) 1489 raise AttributeError, "Frequency object has no attribute '%s'" % attr 1490 1491 # convert latency to ticks 1492 def getValue(self): 1493 if self.ticks or self.value == 0: 1494 value = self.value 1495 else: 1496 value = ticks.fromSeconds(1.0 / self.value) 1497 return long(value) 1498 1499 def config_value(self): 1500 return self.getValue() 1501 1502 def ini_str(self): 1503 return '%d' % self.getValue() 1504 1505# A generic Frequency and/or Latency value. Value is stored as a 1506# latency, just like Latency and Frequency. 1507class Clock(TickParamValue): 1508 def __init__(self, value): 1509 if isinstance(value, (Latency, Clock)): 1510 self.ticks = value.ticks 1511 self.value = value.value 1512 elif isinstance(value, Frequency): 1513 self.ticks = value.ticks 1514 self.value = 1.0 / value.value 1515 elif value.endswith('t'): 1516 self.ticks = True 1517 self.value = int(value[:-1]) 1518 else: 1519 self.ticks = False 1520 self.value = convert.anyToLatency(value) 1521 1522 def __call__(self, value): 1523 self.__init__(value) 1524 return value 1525 1526 def __str__(self): 1527 return "%s" % Latency(self) 1528 1529 def __getattr__(self, attr): 1530 if attr == 'frequency': 1531 return Frequency(self) 1532 if attr in ('latency', 'period'): 1533 return Latency(self) 1534 raise AttributeError, "Frequency object has no attribute '%s'" % attr 1535 1536 def getValue(self): 1537 return self.period.getValue() 1538 1539 def config_value(self): 1540 return self.period.config_value() 1541 1542 def ini_str(self): 1543 return self.period.ini_str() 1544 1545class Voltage(float,ParamValue): 1546 cxx_type = 'double' 1547 ex_str = "1V" 1548 cmd_line_settable = True 1549 1550 def __new__(cls, value): 1551 # convert to voltage 1552 val = convert.toVoltage(value) 1553 return super(cls, Voltage).__new__(cls, val) 1554 1555 def __call__(self, value): 1556 val = convert.toVoltage(value) 1557 self.__init__(val) 1558 return value 1559 1560 def __str__(self): 1561 return str(self.getValue()) 1562 1563 def getValue(self): 1564 value = float(self) 1565 return value 1566 1567 def ini_str(self): 1568 return '%f' % self.getValue() 1569 1570 @classmethod 1571 def cxx_ini_predecls(cls, code): 1572 code('#include <sstream>') 1573 1574 @classmethod 1575 def cxx_ini_parse(self, code, src, dest, ret): 1576 code('%s (std::istringstream(%s) >> %s).eof();' % (ret, src, dest)) 1577 1578class Current(float, ParamValue): 1579 cxx_type = 'double' 1580 ex_str = "1mA" 1581 cmd_line_settable = False 1582 1583 def __new__(cls, value): 1584 # convert to current 1585 val = convert.toCurrent(value) 1586 return super(cls, Current).__new__(cls, val) 1587 1588 def __call__(self, value): 1589 val = convert.toCurrent(value) 1590 self.__init__(val) 1591 return value 1592 1593 def __str__(self): 1594 return str(self.getValue()) 1595 1596 def getValue(self): 1597 value = float(self) 1598 return value 1599 1600 def ini_str(self): 1601 return '%f' % self.getValue() 1602 1603 @classmethod 1604 def cxx_ini_predecls(cls, code): 1605 code('#include <sstream>') 1606 1607 @classmethod 1608 def cxx_ini_parse(self, code, src, dest, ret): 1609 code('%s (std::istringstream(%s) >> %s).eof();' % (ret, src, dest)) 1610 1611class NetworkBandwidth(float,ParamValue): 1612 cxx_type = 'float' 1613 ex_str = "1Gbps" 1614 cmd_line_settable = True 1615 1616 def __new__(cls, value): 1617 # convert to bits per second 1618 val = convert.toNetworkBandwidth(value) 1619 return super(cls, NetworkBandwidth).__new__(cls, val) 1620 1621 def __str__(self): 1622 return str(self.val) 1623 1624 def __call__(self, value): 1625 val = convert.toNetworkBandwidth(value) 1626 self.__init__(val) 1627 return value 1628 1629 def getValue(self): 1630 # convert to seconds per byte 1631 value = 8.0 / float(self) 1632 # convert to ticks per byte 1633 value = ticks.fromSeconds(value) 1634 return float(value) 1635 1636 def ini_str(self): 1637 return '%f' % self.getValue() 1638 1639 def config_value(self): 1640 return '%f' % self.getValue() 1641 1642 @classmethod 1643 def cxx_ini_predecls(cls, code): 1644 code('#include <sstream>') 1645 1646 @classmethod 1647 def cxx_ini_parse(self, code, src, dest, ret): 1648 code('%s (std::istringstream(%s) >> %s).eof();' % (ret, src, dest)) 1649 1650class MemoryBandwidth(float,ParamValue): 1651 cxx_type = 'float' 1652 ex_str = "1GB/s" 1653 cmd_line_settable = True 1654 1655 def __new__(cls, value): 1656 # convert to bytes per second 1657 val = convert.toMemoryBandwidth(value) 1658 return super(cls, MemoryBandwidth).__new__(cls, val) 1659 1660 def __call__(self, value): 1661 val = convert.toMemoryBandwidth(value) 1662 self.__init__(val) 1663 return value 1664 1665 def getValue(self): 1666 # convert to seconds per byte 1667 value = float(self) 1668 if value: 1669 value = 1.0 / float(self) 1670 # convert to ticks per byte 1671 value = ticks.fromSeconds(value) 1672 return float(value) 1673 1674 def ini_str(self): 1675 return '%f' % self.getValue() 1676 1677 def config_value(self): 1678 return '%f' % self.getValue() 1679 1680 @classmethod 1681 def cxx_ini_predecls(cls, code): 1682 code('#include <sstream>') 1683 1684 @classmethod 1685 def cxx_ini_parse(self, code, src, dest, ret): 1686 code('%s (std::istringstream(%s) >> %s).eof();' % (ret, src, dest)) 1687 1688# 1689# "Constants"... handy aliases for various values. 1690# 1691 1692# Special class for NULL pointers. Note the special check in 1693# make_param_value() above that lets these be assigned where a 1694# SimObject is required. 1695# only one copy of a particular node 1696class NullSimObject(object): 1697 __metaclass__ = Singleton 1698 1699 def __call__(cls): 1700 return cls 1701 1702 def _instantiate(self, parent = None, path = ''): 1703 pass 1704 1705 def ini_str(self): 1706 return 'Null' 1707 1708 def unproxy(self, base): 1709 return self 1710 1711 def set_path(self, parent, name): 1712 pass 1713 1714 def set_parent(self, parent, name): 1715 pass 1716 1717 def __str__(self): 1718 return 'Null' 1719 1720 def config_value(self): 1721 return None 1722 1723 def getValue(self): 1724 return None 1725 1726# The only instance you'll ever need... 1727NULL = NullSimObject() 1728 1729def isNullPointer(value): 1730 return isinstance(value, NullSimObject) 1731 1732# Some memory range specifications use this as a default upper bound. 1733MaxAddr = Addr.max 1734MaxTick = Tick.max 1735AllMemory = AddrRange(0, MaxAddr) 1736 1737 1738##################################################################### 1739# 1740# Port objects 1741# 1742# Ports are used to interconnect objects in the memory system. 1743# 1744##################################################################### 1745 1746# Port reference: encapsulates a reference to a particular port on a 1747# particular SimObject. 1748class PortRef(object): 1749 def __init__(self, simobj, name, role): 1750 assert(isSimObject(simobj) or isSimObjectClass(simobj)) 1751 self.simobj = simobj 1752 self.name = name 1753 self.role = role 1754 self.peer = None # not associated with another port yet 1755 self.ccConnected = False # C++ port connection done? 1756 self.index = -1 # always -1 for non-vector ports 1757 1758 def __str__(self): 1759 return '%s.%s' % (self.simobj, self.name) 1760 1761 def __len__(self): 1762 # Return the number of connected ports, i.e. 0 is we have no 1763 # peer and 1 if we do. 1764 return int(self.peer != None) 1765 1766 # for config.ini, print peer's name (not ours) 1767 def ini_str(self): 1768 return str(self.peer) 1769 1770 # for config.json 1771 def get_config_as_dict(self): 1772 return {'role' : self.role, 'peer' : str(self.peer)} 1773 1774 def __getattr__(self, attr): 1775 if attr == 'peerObj': 1776 # shorthand for proxies 1777 return self.peer.simobj 1778 raise AttributeError, "'%s' object has no attribute '%s'" % \ 1779 (self.__class__.__name__, attr) 1780 1781 # Full connection is symmetric (both ways). Called via 1782 # SimObject.__setattr__ as a result of a port assignment, e.g., 1783 # "obj1.portA = obj2.portB", or via VectorPortElementRef.__setitem__, 1784 # e.g., "obj1.portA[3] = obj2.portB". 1785 def connect(self, other): 1786 if isinstance(other, VectorPortRef): 1787 # reference to plain VectorPort is implicit append 1788 other = other._get_next() 1789 if self.peer and not proxy.isproxy(self.peer): 1790 fatal("Port %s is already connected to %s, cannot connect %s\n", 1791 self, self.peer, other); 1792 self.peer = other 1793 if proxy.isproxy(other): 1794 other.set_param_desc(PortParamDesc()) 1795 elif isinstance(other, PortRef): 1796 if other.peer is not self: 1797 other.connect(self) 1798 else: 1799 raise TypeError, \ 1800 "assigning non-port reference '%s' to port '%s'" \ 1801 % (other, self) 1802 1803 # Allow a master/slave port pair to be spliced between 1804 # a port and its connected peer. Useful operation for connecting 1805 # instrumentation structures into a system when it is necessary 1806 # to connect the instrumentation after the full system has been 1807 # constructed. 1808 def splice(self, new_master_peer, new_slave_peer): 1809 if self.peer and not proxy.isproxy(self.peer): 1810 if isinstance(new_master_peer, PortRef) and \ 1811 isinstance(new_slave_peer, PortRef): 1812 old_peer = self.peer 1813 if self.role == 'SLAVE': 1814 self.peer = new_master_peer 1815 old_peer.peer = new_slave_peer 1816 new_master_peer.connect(self) 1817 new_slave_peer.connect(old_peer) 1818 elif self.role == 'MASTER': 1819 self.peer = new_slave_peer 1820 old_peer.peer = new_master_peer 1821 new_slave_peer.connect(self) 1822 new_master_peer.connect(old_peer) 1823 else: 1824 panic("Port %s has unknown role, "+\ 1825 "cannot splice in new peers\n", self) 1826 else: 1827 raise TypeError, \ 1828 "Splicing non-port references '%s','%s' to port '%s'"\ 1829 % (new_peer, peers_new_peer, self) 1830 else: 1831 fatal("Port %s not connected, cannot splice in new peers\n", self) 1832 1833 def clone(self, simobj, memo): 1834 if memo.has_key(self): 1835 return memo[self] 1836 newRef = copy.copy(self) 1837 memo[self] = newRef 1838 newRef.simobj = simobj 1839 assert(isSimObject(newRef.simobj)) 1840 if self.peer and not proxy.isproxy(self.peer): 1841 peerObj = self.peer.simobj(_memo=memo) 1842 newRef.peer = self.peer.clone(peerObj, memo) 1843 assert(not isinstance(newRef.peer, VectorPortRef)) 1844 return newRef 1845 1846 def unproxy(self, simobj): 1847 assert(simobj is self.simobj) 1848 if proxy.isproxy(self.peer): 1849 try: 1850 realPeer = self.peer.unproxy(self.simobj) 1851 except: 1852 print "Error in unproxying port '%s' of %s" % \ 1853 (self.name, self.simobj.path()) 1854 raise 1855 self.connect(realPeer) 1856 1857 # Call C++ to create corresponding port connection between C++ objects 1858 def ccConnect(self): 1859 from _m5.pyobject import connectPorts 1860 1861 if self.role == 'SLAVE': 1862 # do nothing and let the master take care of it 1863 return 1864 1865 if self.ccConnected: # already done this 1866 return 1867 peer = self.peer 1868 if not self.peer: # nothing to connect to 1869 return 1870 1871 # check that we connect a master to a slave 1872 if self.role == peer.role: 1873 raise TypeError, \ 1874 "cannot connect '%s' and '%s' due to identical role '%s'" \ 1875 % (peer, self, self.role) 1876 1877 try: 1878 # self is always the master and peer the slave 1879 connectPorts(self.simobj.getCCObject(), self.name, self.index, 1880 peer.simobj.getCCObject(), peer.name, peer.index) 1881 except: 1882 print "Error connecting port %s.%s to %s.%s" % \ 1883 (self.simobj.path(), self.name, 1884 peer.simobj.path(), peer.name) 1885 raise 1886 self.ccConnected = True 1887 peer.ccConnected = True 1888 1889# A reference to an individual element of a VectorPort... much like a 1890# PortRef, but has an index. 1891class VectorPortElementRef(PortRef): 1892 def __init__(self, simobj, name, role, index): 1893 PortRef.__init__(self, simobj, name, role) 1894 self.index = index 1895 1896 def __str__(self): 1897 return '%s.%s[%d]' % (self.simobj, self.name, self.index) 1898 1899# A reference to a complete vector-valued port (not just a single element). 1900# Can be indexed to retrieve individual VectorPortElementRef instances. 1901class VectorPortRef(object): 1902 def __init__(self, simobj, name, role): 1903 assert(isSimObject(simobj) or isSimObjectClass(simobj)) 1904 self.simobj = simobj 1905 self.name = name 1906 self.role = role 1907 self.elements = [] 1908 1909 def __str__(self): 1910 return '%s.%s[:]' % (self.simobj, self.name) 1911 1912 def __len__(self): 1913 # Return the number of connected peers, corresponding the the 1914 # length of the elements. 1915 return len(self.elements) 1916 1917 # for config.ini, print peer's name (not ours) 1918 def ini_str(self): 1919 return ' '.join([el.ini_str() for el in self.elements]) 1920 1921 # for config.json 1922 def get_config_as_dict(self): 1923 return {'role' : self.role, 1924 'peer' : [el.ini_str() for el in self.elements]} 1925 1926 def __getitem__(self, key): 1927 if not isinstance(key, int): 1928 raise TypeError, "VectorPort index must be integer" 1929 if key >= len(self.elements): 1930 # need to extend list 1931 ext = [VectorPortElementRef(self.simobj, self.name, self.role, i) 1932 for i in range(len(self.elements), key+1)] 1933 self.elements.extend(ext) 1934 return self.elements[key] 1935 1936 def _get_next(self): 1937 return self[len(self.elements)] 1938 1939 def __setitem__(self, key, value): 1940 if not isinstance(key, int): 1941 raise TypeError, "VectorPort index must be integer" 1942 self[key].connect(value) 1943 1944 def connect(self, other): 1945 if isinstance(other, (list, tuple)): 1946 # Assign list of port refs to vector port. 1947 # For now, append them... not sure if that's the right semantics 1948 # or if it should replace the current vector. 1949 for ref in other: 1950 self._get_next().connect(ref) 1951 else: 1952 # scalar assignment to plain VectorPort is implicit append 1953 self._get_next().connect(other) 1954 1955 def clone(self, simobj, memo): 1956 if memo.has_key(self): 1957 return memo[self] 1958 newRef = copy.copy(self) 1959 memo[self] = newRef 1960 newRef.simobj = simobj 1961 assert(isSimObject(newRef.simobj)) 1962 newRef.elements = [el.clone(simobj, memo) for el in self.elements] 1963 return newRef 1964 1965 def unproxy(self, simobj): 1966 [el.unproxy(simobj) for el in self.elements] 1967 1968 def ccConnect(self): 1969 [el.ccConnect() for el in self.elements] 1970 1971# Port description object. Like a ParamDesc object, this represents a 1972# logical port in the SimObject class, not a particular port on a 1973# SimObject instance. The latter are represented by PortRef objects. 1974class Port(object): 1975 # Generate a PortRef for this port on the given SimObject with the 1976 # given name 1977 def makeRef(self, simobj): 1978 return PortRef(simobj, self.name, self.role) 1979 1980 # Connect an instance of this port (on the given SimObject with 1981 # the given name) with the port described by the supplied PortRef 1982 def connect(self, simobj, ref): 1983 self.makeRef(simobj).connect(ref) 1984 1985 # No need for any pre-declarations at the moment as we merely rely 1986 # on an unsigned int. 1987 def cxx_predecls(self, code): 1988 pass 1989 1990 def pybind_predecls(self, code): 1991 cls.cxx_predecls(self, code) 1992 1993 # Declare an unsigned int with the same name as the port, that 1994 # will eventually hold the number of connected ports (and thus the 1995 # number of elements for a VectorPort). 1996 def cxx_decl(self, code): 1997 code('unsigned int port_${{self.name}}_connection_count;') 1998 1999class MasterPort(Port): 2000 # MasterPort("description") 2001 def __init__(self, *args): 2002 if len(args) == 1: 2003 self.desc = args[0] 2004 self.role = 'MASTER' 2005 else: 2006 raise TypeError, 'wrong number of arguments' 2007 2008class SlavePort(Port): 2009 # SlavePort("description") 2010 def __init__(self, *args): 2011 if len(args) == 1: 2012 self.desc = args[0] 2013 self.role = 'SLAVE' 2014 else: 2015 raise TypeError, 'wrong number of arguments' 2016 2017# VectorPort description object. Like Port, but represents a vector 2018# of connections (e.g., as on a XBar). 2019class VectorPort(Port): 2020 def __init__(self, *args): 2021 self.isVec = True 2022 2023 def makeRef(self, simobj): 2024 return VectorPortRef(simobj, self.name, self.role) 2025 2026class VectorMasterPort(VectorPort): 2027 # VectorMasterPort("description") 2028 def __init__(self, *args): 2029 if len(args) == 1: 2030 self.desc = args[0] 2031 self.role = 'MASTER' 2032 VectorPort.__init__(self, *args) 2033 else: 2034 raise TypeError, 'wrong number of arguments' 2035 2036class VectorSlavePort(VectorPort): 2037 # VectorSlavePort("description") 2038 def __init__(self, *args): 2039 if len(args) == 1: 2040 self.desc = args[0] 2041 self.role = 'SLAVE' 2042 VectorPort.__init__(self, *args) 2043 else: 2044 raise TypeError, 'wrong number of arguments' 2045 2046# 'Fake' ParamDesc for Port references to assign to the _pdesc slot of 2047# proxy objects (via set_param_desc()) so that proxy error messages 2048# make sense. 2049class PortParamDesc(object): 2050 __metaclass__ = Singleton 2051 2052 ptype_str = 'Port' 2053 ptype = Port 2054 2055baseEnums = allEnums.copy() 2056baseParams = allParams.copy() 2057 2058def clear(): 2059 global allEnums, allParams 2060 2061 allEnums = baseEnums.copy() 2062 allParams = baseParams.copy() 2063 2064__all__ = ['Param', 'VectorParam', 2065 'Enum', 'Bool', 'String', 'Float', 2066 'Int', 'Unsigned', 'Int8', 'UInt8', 'Int16', 'UInt16', 2067 'Int32', 'UInt32', 'Int64', 'UInt64', 2068 'Counter', 'Addr', 'Tick', 'Percent', 2069 'TcpPort', 'UdpPort', 'EthernetAddr', 2070 'IpAddress', 'IpNetmask', 'IpWithPort', 2071 'MemorySize', 'MemorySize32', 2072 'Latency', 'Frequency', 'Clock', 'Voltage', 2073 'NetworkBandwidth', 'MemoryBandwidth', 2074 'AddrRange', 2075 'MaxAddr', 'MaxTick', 'AllMemory', 2076 'Time', 2077 'NextEthernetAddr', 'NULL', 2078 'MasterPort', 'SlavePort', 2079 'VectorMasterPort', 'VectorSlavePort'] 2080 2081import SimObject 2082