StateMachine.py revision 8938:7925057dc4d8
1# Copyright (c) 1999-2008 Mark D. Hill and David A. Wood 2# Copyright (c) 2009 The Hewlett-Packard Development Company 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 28from m5.util import orderdict 29 30from slicc.symbols.Symbol import Symbol 31from slicc.symbols.Var import Var 32import slicc.generate.html as html 33import re 34 35python_class_map = {"int": "Int", 36 "std::string": "String", 37 "bool": "Bool", 38 "CacheMemory": "RubyCache", 39 "WireBuffer": "RubyWireBuffer", 40 "Sequencer": "RubySequencer", 41 "DirectoryMemory": "RubyDirectoryMemory", 42 "MemoryControl": "RubyMemoryControl", 43 "DMASequencer": "DMASequencer" 44 } 45 46class StateMachine(Symbol): 47 def __init__(self, symtab, ident, location, pairs, config_parameters): 48 super(StateMachine, self).__init__(symtab, ident, location, pairs) 49 self.table = None 50 self.config_parameters = config_parameters 51 52 for param in config_parameters: 53 if param.pointer: 54 var = Var(symtab, param.name, location, param.type_ast.type, 55 "(*m_%s_ptr)" % param.name, {}, self) 56 else: 57 var = Var(symtab, param.name, location, param.type_ast.type, 58 "m_%s" % param.name, {}, self) 59 self.symtab.registerSym(param.name, var) 60 61 self.states = orderdict() 62 self.events = orderdict() 63 self.actions = orderdict() 64 self.transitions = [] 65 self.in_ports = [] 66 self.functions = [] 67 self.objects = [] 68 self.TBEType = None 69 self.EntryType = None 70 71 self.message_buffer_names = [] 72 73 def __repr__(self): 74 return "[StateMachine: %s]" % self.ident 75 76 def addState(self, state): 77 assert self.table is None 78 self.states[state.ident] = state 79 80 def addEvent(self, event): 81 assert self.table is None 82 self.events[event.ident] = event 83 84 def addAction(self, action): 85 assert self.table is None 86 87 # Check for duplicate action 88 for other in self.actions.itervalues(): 89 if action.ident == other.ident: 90 action.warning("Duplicate action definition: %s" % action.ident) 91 action.error("Duplicate action definition: %s" % action.ident) 92 if action.short == other.short: 93 other.warning("Duplicate action shorthand: %s" % other.ident) 94 other.warning(" shorthand = %s" % other.short) 95 action.warning("Duplicate action shorthand: %s" % action.ident) 96 action.error(" shorthand = %s" % action.short) 97 98 self.actions[action.ident] = action 99 100 def addTransition(self, trans): 101 assert self.table is None 102 self.transitions.append(trans) 103 104 def addInPort(self, var): 105 self.in_ports.append(var) 106 107 def addFunc(self, func): 108 # register func in the symbol table 109 self.symtab.registerSym(str(func), func) 110 self.functions.append(func) 111 112 def addObject(self, obj): 113 self.objects.append(obj) 114 115 def addType(self, type): 116 type_ident = '%s' % type.c_ident 117 118 if type_ident == "%s_TBE" %self.ident: 119 if self.TBEType != None: 120 self.error("Multiple Transaction Buffer types in a " \ 121 "single machine."); 122 self.TBEType = type 123 124 elif "interface" in type and "AbstractCacheEntry" == type["interface"]: 125 if self.EntryType != None: 126 self.error("Multiple AbstractCacheEntry types in a " \ 127 "single machine."); 128 self.EntryType = type 129 130 # Needs to be called before accessing the table 131 def buildTable(self): 132 assert self.table is None 133 134 table = {} 135 136 for trans in self.transitions: 137 # Track which actions we touch so we know if we use them 138 # all -- really this should be done for all symbols as 139 # part of the symbol table, then only trigger it for 140 # Actions, States, Events, etc. 141 142 for action in trans.actions: 143 action.used = True 144 145 index = (trans.state, trans.event) 146 if index in table: 147 table[index].warning("Duplicate transition: %s" % table[index]) 148 trans.error("Duplicate transition: %s" % trans) 149 table[index] = trans 150 151 # Look at all actions to make sure we used them all 152 for action in self.actions.itervalues(): 153 if not action.used: 154 error_msg = "Unused action: %s" % action.ident 155 if "desc" in action: 156 error_msg += ", " + action.desc 157 action.warning(error_msg) 158 self.table = table 159 160 def writeCodeFiles(self, path): 161 self.printControllerPython(path) 162 self.printControllerHH(path) 163 self.printControllerCC(path) 164 self.printCSwitch(path) 165 self.printCWakeup(path) 166 self.printProfilerCC(path) 167 self.printProfilerHH(path) 168 self.printProfileDumperCC(path) 169 self.printProfileDumperHH(path) 170 171 def printControllerPython(self, path): 172 code = self.symtab.codeFormatter() 173 ident = self.ident 174 py_ident = "%s_Controller" % ident 175 c_ident = "%s_Controller" % self.ident 176 code(''' 177from m5.params import * 178from m5.SimObject import SimObject 179from Controller import RubyController 180 181class $py_ident(RubyController): 182 type = '$py_ident' 183''') 184 code.indent() 185 for param in self.config_parameters: 186 dflt_str = '' 187 if param.default is not None: 188 dflt_str = str(param.default) + ', ' 189 if python_class_map.has_key(param.type_ast.type.c_ident): 190 python_type = python_class_map[param.type_ast.type.c_ident] 191 code('${{param.name}} = Param.${{python_type}}(${dflt_str}"")') 192 else: 193 self.error("Unknown c++ to python class conversion for c++ " \ 194 "type: '%s'. Please update the python_class_map " \ 195 "in StateMachine.py", param.type_ast.type.c_ident) 196 code.dedent() 197 code.write(path, '%s.py' % py_ident) 198 199 200 def printControllerHH(self, path): 201 '''Output the method declarations for the class declaration''' 202 code = self.symtab.codeFormatter() 203 ident = self.ident 204 c_ident = "%s_Controller" % self.ident 205 206 self.message_buffer_names = [] 207 208 code(''' 209/** \\file $c_ident.hh 210 * 211 * Auto generated C++ code started by $__file__:$__line__ 212 * Created by slicc definition of Module "${{self.short}}" 213 */ 214 215#ifndef __${ident}_CONTROLLER_HH__ 216#define __${ident}_CONTROLLER_HH__ 217 218#include <iostream> 219#include <sstream> 220#include <string> 221 222#include "mem/protocol/${ident}_ProfileDumper.hh" 223#include "mem/protocol/${ident}_Profiler.hh" 224#include "mem/protocol/TransitionResult.hh" 225#include "mem/protocol/Types.hh" 226#include "mem/ruby/common/Consumer.hh" 227#include "mem/ruby/common/Global.hh" 228#include "mem/ruby/slicc_interface/AbstractController.hh" 229#include "params/$c_ident.hh" 230''') 231 232 seen_types = set() 233 for var in self.objects: 234 if var.type.ident not in seen_types and not var.type.isPrimitive: 235 code('#include "mem/protocol/${{var.type.c_ident}}.hh"') 236 seen_types.add(var.type.ident) 237 238 # for adding information to the protocol debug trace 239 code(''' 240extern std::stringstream ${ident}_transitionComment; 241 242class $c_ident : public AbstractController 243{ 244// the coherence checker needs to call isBlockExclusive() and isBlockShared() 245// making the Chip a friend class is an easy way to do this for now 246 247public: 248 typedef ${c_ident}Params Params; 249 $c_ident(const Params *p); 250 static int getNumControllers(); 251 void init(); 252 MessageBuffer* getMandatoryQueue() const; 253 const int & getVersion() const; 254 const std::string toString() const; 255 const std::string getName() const; 256 void stallBuffer(MessageBuffer* buf, Address addr); 257 void wakeUpBuffers(Address addr); 258 void wakeUpAllBuffers(); 259 void initNetworkPtr(Network* net_ptr) { m_net_ptr = net_ptr; } 260 void print(std::ostream& out) const; 261 void printConfig(std::ostream& out) const; 262 void wakeup(); 263 void printStats(std::ostream& out) const; 264 void clearStats(); 265 void blockOnQueue(Address addr, MessageBuffer* port); 266 void unblock(Address addr); 267 void recordCacheTrace(int cntrl, CacheRecorder* tr); 268 Sequencer* getSequencer() const; 269 270private: 271''') 272 273 code.indent() 274 # added by SS 275 for param in self.config_parameters: 276 if param.pointer: 277 code('${{param.type_ast.type}}* m_${{param.ident}}_ptr;') 278 else: 279 code('${{param.type_ast.type}} m_${{param.ident}};') 280 281 code(''' 282int m_number_of_TBEs; 283 284TransitionResult doTransition(${ident}_Event event, 285''') 286 287 if self.EntryType != None: 288 code(''' 289 ${{self.EntryType.c_ident}}* m_cache_entry_ptr, 290''') 291 if self.TBEType != None: 292 code(''' 293 ${{self.TBEType.c_ident}}* m_tbe_ptr, 294''') 295 296 code(''' 297 const Address& addr); 298 299TransitionResult doTransitionWorker(${ident}_Event event, 300 ${ident}_State state, 301 ${ident}_State& next_state, 302''') 303 304 if self.TBEType != None: 305 code(''' 306 ${{self.TBEType.c_ident}}*& m_tbe_ptr, 307''') 308 if self.EntryType != None: 309 code(''' 310 ${{self.EntryType.c_ident}}*& m_cache_entry_ptr, 311''') 312 313 code(''' 314 const Address& addr); 315 316std::string m_name; 317int m_transitions_per_cycle; 318int m_buffer_size; 319int m_recycle_latency; 320std::map<std::string, std::string> m_cfg; 321NodeID m_version; 322Network* m_net_ptr; 323MachineID m_machineID; 324bool m_is_blocking; 325std::map<Address, MessageBuffer*> m_block_map; 326typedef std::vector<MessageBuffer*> MsgVecType; 327typedef m5::hash_map< Address, MsgVecType* > WaitingBufType; 328WaitingBufType m_waiting_buffers; 329int m_max_in_port_rank; 330int m_cur_in_port_rank; 331static ${ident}_ProfileDumper s_profileDumper; 332${ident}_Profiler m_profiler; 333static int m_num_controllers; 334 335// Internal functions 336''') 337 338 for func in self.functions: 339 proto = func.prototype 340 if proto: 341 code('$proto') 342 343 if self.EntryType != None: 344 code(''' 345 346// Set and Reset for cache_entry variable 347void set_cache_entry(${{self.EntryType.c_ident}}*& m_cache_entry_ptr, AbstractCacheEntry* m_new_cache_entry); 348void unset_cache_entry(${{self.EntryType.c_ident}}*& m_cache_entry_ptr); 349''') 350 351 if self.TBEType != None: 352 code(''' 353 354// Set and Reset for tbe variable 355void set_tbe(${{self.TBEType.c_ident}}*& m_tbe_ptr, ${ident}_TBE* m_new_tbe); 356void unset_tbe(${{self.TBEType.c_ident}}*& m_tbe_ptr); 357''') 358 359 code(''' 360 361// Actions 362''') 363 if self.TBEType != None and self.EntryType != None: 364 for action in self.actions.itervalues(): 365 code('/** \\brief ${{action.desc}} */') 366 code('void ${{action.ident}}(${{self.TBEType.c_ident}}*& m_tbe_ptr, ${{self.EntryType.c_ident}}*& m_cache_entry_ptr, const Address& addr);') 367 elif self.TBEType != None: 368 for action in self.actions.itervalues(): 369 code('/** \\brief ${{action.desc}} */') 370 code('void ${{action.ident}}(${{self.TBEType.c_ident}}*& m_tbe_ptr, const Address& addr);') 371 elif self.EntryType != None: 372 for action in self.actions.itervalues(): 373 code('/** \\brief ${{action.desc}} */') 374 code('void ${{action.ident}}(${{self.EntryType.c_ident}}*& m_cache_entry_ptr, const Address& addr);') 375 else: 376 for action in self.actions.itervalues(): 377 code('/** \\brief ${{action.desc}} */') 378 code('void ${{action.ident}}(const Address& addr);') 379 380 # the controller internal variables 381 code(''' 382 383// Objects 384''') 385 for var in self.objects: 386 th = var.get("template_hack", "") 387 code('${{var.type.c_ident}}$th* m_${{var.c_ident}}_ptr;') 388 389 if var.type.ident == "MessageBuffer": 390 self.message_buffer_names.append("m_%s_ptr" % var.c_ident) 391 392 code.dedent() 393 code('};') 394 code('#endif // __${ident}_CONTROLLER_H__') 395 code.write(path, '%s.hh' % c_ident) 396 397 def printControllerCC(self, path): 398 '''Output the actions for performing the actions''' 399 400 code = self.symtab.codeFormatter() 401 ident = self.ident 402 c_ident = "%s_Controller" % self.ident 403 404 code(''' 405/** \\file $c_ident.cc 406 * 407 * Auto generated C++ code started by $__file__:$__line__ 408 * Created by slicc definition of Module "${{self.short}}" 409 */ 410 411#include <cassert> 412#include <sstream> 413#include <string> 414 415#include "base/compiler.hh" 416#include "base/cprintf.hh" 417#include "debug/RubyGenerated.hh" 418#include "debug/RubySlicc.hh" 419#include "mem/protocol/${ident}_Controller.hh" 420#include "mem/protocol/${ident}_Event.hh" 421#include "mem/protocol/${ident}_State.hh" 422#include "mem/protocol/Types.hh" 423#include "mem/ruby/common/Global.hh" 424#include "mem/ruby/slicc_interface/RubySlicc_includes.hh" 425#include "mem/ruby/system/System.hh" 426 427using namespace std; 428''') 429 430 # include object classes 431 seen_types = set() 432 for var in self.objects: 433 if var.type.ident not in seen_types and not var.type.isPrimitive: 434 code('#include "mem/protocol/${{var.type.c_ident}}.hh"') 435 seen_types.add(var.type.ident) 436 437 code(''' 438$c_ident * 439${c_ident}Params::create() 440{ 441 return new $c_ident(this); 442} 443 444int $c_ident::m_num_controllers = 0; 445${ident}_ProfileDumper $c_ident::s_profileDumper; 446 447// for adding information to the protocol debug trace 448stringstream ${ident}_transitionComment; 449#define APPEND_TRANSITION_COMMENT(str) (${ident}_transitionComment << str) 450 451/** \\brief constructor */ 452$c_ident::$c_ident(const Params *p) 453 : AbstractController(p) 454{ 455 m_version = p->version; 456 m_transitions_per_cycle = p->transitions_per_cycle; 457 m_buffer_size = p->buffer_size; 458 m_recycle_latency = p->recycle_latency; 459 m_number_of_TBEs = p->number_of_TBEs; 460 m_is_blocking = false; 461 m_name = "${ident}"; 462''') 463 # 464 # max_port_rank is used to size vectors and thus should be one plus the 465 # largest port rank 466 # 467 max_port_rank = self.in_ports[0].pairs["max_port_rank"] + 1 468 code(' m_max_in_port_rank = $max_port_rank;') 469 code.indent() 470 471 # 472 # After initializing the universal machine parameters, initialize the 473 # this machines config parameters. Also detemine if these configuration 474 # params include a sequencer. This information will be used later for 475 # contecting the sequencer back to the L1 cache controller. 476 # 477 contains_dma_sequencer = False 478 sequencers = [] 479 for param in self.config_parameters: 480 if param.name == "dma_sequencer": 481 contains_dma_sequencer = True 482 elif re.compile("sequencer").search(param.name): 483 sequencers.append(param.name) 484 if param.pointer: 485 code('m_${{param.name}}_ptr = p->${{param.name}};') 486 else: 487 code('m_${{param.name}} = p->${{param.name}};') 488 489 # 490 # For the l1 cache controller, add the special atomic support which 491 # includes passing the sequencer a pointer to the controller. 492 # 493 if self.ident == "L1Cache": 494 if not sequencers: 495 self.error("The L1Cache controller must include the sequencer " \ 496 "configuration parameter") 497 498 for seq in sequencers: 499 code(''' 500m_${{seq}}_ptr->setController(this); 501 ''') 502 503 else: 504 for seq in sequencers: 505 code(''' 506m_${{seq}}_ptr->setController(this); 507 ''') 508 509 # 510 # For the DMA controller, pass the sequencer a pointer to the 511 # controller. 512 # 513 if self.ident == "DMA": 514 if not contains_dma_sequencer: 515 self.error("The DMA controller must include the sequencer " \ 516 "configuration parameter") 517 518 code(''' 519m_dma_sequencer_ptr->setController(this); 520''') 521 522 code('m_num_controllers++;') 523 for var in self.objects: 524 if var.ident.find("mandatoryQueue") >= 0: 525 code('m_${{var.c_ident}}_ptr = new ${{var.type.c_ident}}();') 526 527 code.dedent() 528 code(''' 529} 530 531void 532$c_ident::init() 533{ 534 MachineType machine_type; 535 int base; 536 537 m_machineID.type = MachineType_${ident}; 538 m_machineID.num = m_version; 539 540 // initialize objects 541 m_profiler.setVersion(m_version); 542 s_profileDumper.registerProfiler(&m_profiler); 543 544''') 545 546 code.indent() 547 for var in self.objects: 548 vtype = var.type 549 vid = "m_%s_ptr" % var.c_ident 550 if "network" not in var: 551 # Not a network port object 552 if "primitive" in vtype: 553 code('$vid = new ${{vtype.c_ident}};') 554 if "default" in var: 555 code('(*$vid) = ${{var["default"]}};') 556 else: 557 # Normal Object 558 # added by SS 559 if "factory" in var: 560 code('$vid = ${{var["factory"]}};') 561 elif var.ident.find("mandatoryQueue") < 0: 562 th = var.get("template_hack", "") 563 expr = "%s = new %s%s" % (vid, vtype.c_ident, th) 564 565 args = "" 566 if "non_obj" not in vtype and not vtype.isEnumeration: 567 if expr.find("TBETable") >= 0: 568 args = "m_number_of_TBEs" 569 else: 570 args = var.get("constructor_hack", "") 571 572 code('$expr($args);') 573 574 code('assert($vid != NULL);') 575 576 if "default" in var: 577 code('*$vid = ${{var["default"]}}; // Object default') 578 elif "default" in vtype: 579 comment = "Type %s default" % vtype.ident 580 code('*$vid = ${{vtype["default"]}}; // $comment') 581 582 # Set ordering 583 if "ordered" in var and "trigger_queue" not in var: 584 # A buffer 585 code('$vid->setOrdering(${{var["ordered"]}});') 586 587 # Set randomization 588 if "random" in var: 589 # A buffer 590 code('$vid->setRandomization(${{var["random"]}});') 591 592 # Set Priority 593 if vtype.isBuffer and \ 594 "rank" in var and "trigger_queue" not in var: 595 code('$vid->setPriority(${{var["rank"]}});') 596 597 else: 598 # Network port object 599 network = var["network"] 600 ordered = var["ordered"] 601 vnet = var["virtual_network"] 602 vnet_type = var["vnet_type"] 603 604 assert var.machine is not None 605 code(''' 606machine_type = string_to_MachineType("${{var.machine.ident}}"); 607base = MachineType_base_number(machine_type); 608$vid = m_net_ptr->get${network}NetQueue(m_version + base, $ordered, $vnet, "$vnet_type"); 609''') 610 611 code('assert($vid != NULL);') 612 613 # Set ordering 614 if "ordered" in var: 615 # A buffer 616 code('$vid->setOrdering(${{var["ordered"]}});') 617 618 # Set randomization 619 if "random" in var: 620 # A buffer 621 code('$vid->setRandomization(${{var["random"]}});') 622 623 # Set Priority 624 if "rank" in var: 625 code('$vid->setPriority(${{var["rank"]}})') 626 627 # Set buffer size 628 if vtype.isBuffer: 629 code(''' 630if (m_buffer_size > 0) { 631 $vid->resize(m_buffer_size); 632} 633''') 634 635 # set description (may be overriden later by port def) 636 code(''' 637$vid->setDescription("[Version " + to_string(m_version) + ", ${ident}, name=${{var.c_ident}}]"); 638 639''') 640 641 if vtype.isBuffer: 642 if "recycle_latency" in var: 643 code('$vid->setRecycleLatency(${{var["recycle_latency"]}});') 644 else: 645 code('$vid->setRecycleLatency(m_recycle_latency);') 646 647 648 # Set the queue consumers 649 code() 650 for port in self.in_ports: 651 code('${{port.code}}.setConsumer(this);') 652 653 # Set the queue descriptions 654 code() 655 for port in self.in_ports: 656 code('${{port.code}}.setDescription("[Version " + to_string(m_version) + ", $ident, $port]");') 657 658 # Initialize the transition profiling 659 code() 660 for trans in self.transitions: 661 # Figure out if we stall 662 stall = False 663 for action in trans.actions: 664 if action.ident == "z_stall": 665 stall = True 666 667 # Only possible if it is not a 'z' case 668 if not stall: 669 state = "%s_State_%s" % (self.ident, trans.state.ident) 670 event = "%s_Event_%s" % (self.ident, trans.event.ident) 671 code('m_profiler.possibleTransition($state, $event);') 672 673 code.dedent() 674 code('}') 675 676 has_mandatory_q = False 677 for port in self.in_ports: 678 if port.code.find("mandatoryQueue_ptr") >= 0: 679 has_mandatory_q = True 680 681 if has_mandatory_q: 682 mq_ident = "m_%s_mandatoryQueue_ptr" % self.ident 683 else: 684 mq_ident = "NULL" 685 686 seq_ident = "NULL" 687 for param in self.config_parameters: 688 if param.name == "sequencer": 689 assert(param.pointer) 690 seq_ident = "m_%s_ptr" % param.name 691 692 code(''' 693int 694$c_ident::getNumControllers() 695{ 696 return m_num_controllers; 697} 698 699MessageBuffer* 700$c_ident::getMandatoryQueue() const 701{ 702 return $mq_ident; 703} 704 705Sequencer* 706$c_ident::getSequencer() const 707{ 708 return $seq_ident; 709} 710 711const int & 712$c_ident::getVersion() const 713{ 714 return m_version; 715} 716 717const string 718$c_ident::toString() const 719{ 720 return "$c_ident"; 721} 722 723const string 724$c_ident::getName() const 725{ 726 return m_name; 727} 728 729void 730$c_ident::stallBuffer(MessageBuffer* buf, Address addr) 731{ 732 if (m_waiting_buffers.count(addr) == 0) { 733 MsgVecType* msgVec = new MsgVecType; 734 msgVec->resize(m_max_in_port_rank, NULL); 735 m_waiting_buffers[addr] = msgVec; 736 } 737 (*(m_waiting_buffers[addr]))[m_cur_in_port_rank] = buf; 738} 739 740void 741$c_ident::wakeUpBuffers(Address addr) 742{ 743 if (m_waiting_buffers.count(addr) > 0) { 744 // 745 // Wake up all possible lower rank (i.e. lower priority) buffers that could 746 // be waiting on this message. 747 // 748 for (int in_port_rank = m_cur_in_port_rank - 1; 749 in_port_rank >= 0; 750 in_port_rank--) { 751 if ((*(m_waiting_buffers[addr]))[in_port_rank] != NULL) { 752 (*(m_waiting_buffers[addr]))[in_port_rank]->reanalyzeMessages(addr); 753 } 754 } 755 delete m_waiting_buffers[addr]; 756 m_waiting_buffers.erase(addr); 757 } 758} 759 760void 761$c_ident::wakeUpAllBuffers() 762{ 763 // 764 // Wake up all possible buffers that could be waiting on any message. 765 // 766 767 std::vector<MsgVecType*> wokeUpMsgVecs; 768 769 if(m_waiting_buffers.size() > 0) { 770 for (WaitingBufType::iterator buf_iter = m_waiting_buffers.begin(); 771 buf_iter != m_waiting_buffers.end(); 772 ++buf_iter) { 773 for (MsgVecType::iterator vec_iter = buf_iter->second->begin(); 774 vec_iter != buf_iter->second->end(); 775 ++vec_iter) { 776 if (*vec_iter != NULL) { 777 (*vec_iter)->reanalyzeAllMessages(); 778 } 779 } 780 wokeUpMsgVecs.push_back(buf_iter->second); 781 } 782 783 for (std::vector<MsgVecType*>::iterator wb_iter = wokeUpMsgVecs.begin(); 784 wb_iter != wokeUpMsgVecs.end(); 785 ++wb_iter) { 786 delete (*wb_iter); 787 } 788 789 m_waiting_buffers.clear(); 790 } 791} 792 793void 794$c_ident::blockOnQueue(Address addr, MessageBuffer* port) 795{ 796 m_is_blocking = true; 797 m_block_map[addr] = port; 798} 799 800void 801$c_ident::unblock(Address addr) 802{ 803 m_block_map.erase(addr); 804 if (m_block_map.size() == 0) { 805 m_is_blocking = false; 806 } 807} 808 809void 810$c_ident::print(ostream& out) const 811{ 812 out << "[$c_ident " << m_version << "]"; 813} 814 815void 816$c_ident::printConfig(ostream& out) const 817{ 818 out << "$c_ident config: " << m_name << endl; 819 out << " version: " << m_version << endl; 820 map<string, string>::const_iterator it; 821 for (it = m_cfg.begin(); it != m_cfg.end(); it++) 822 out << " " << it->first << ": " << it->second << endl; 823} 824 825void 826$c_ident::printStats(ostream& out) const 827{ 828''') 829 # 830 # Cache and Memory Controllers have specific profilers associated with 831 # them. Print out these stats before dumping state transition stats. 832 # 833 for param in self.config_parameters: 834 if param.type_ast.type.ident == "CacheMemory" or \ 835 param.type_ast.type.ident == "DirectoryMemory" or \ 836 param.type_ast.type.ident == "MemoryControl": 837 assert(param.pointer) 838 code(' m_${{param.ident}}_ptr->printStats(out);') 839 840 code(''' 841 if (m_version == 0) { 842 s_profileDumper.dumpStats(out); 843 } 844} 845 846void $c_ident::clearStats() { 847''') 848 # 849 # Cache and Memory Controllers have specific profilers associated with 850 # them. These stats must be cleared too. 851 # 852 for param in self.config_parameters: 853 if param.type_ast.type.ident == "CacheMemory" or \ 854 param.type_ast.type.ident == "MemoryControl": 855 assert(param.pointer) 856 code(' m_${{param.ident}}_ptr->clearStats();') 857 858 code(''' 859 m_profiler.clearStats(); 860} 861''') 862 863 if self.EntryType != None: 864 code(''' 865 866// Set and Reset for cache_entry variable 867void 868$c_ident::set_cache_entry(${{self.EntryType.c_ident}}*& m_cache_entry_ptr, AbstractCacheEntry* m_new_cache_entry) 869{ 870 m_cache_entry_ptr = (${{self.EntryType.c_ident}}*)m_new_cache_entry; 871} 872 873void 874$c_ident::unset_cache_entry(${{self.EntryType.c_ident}}*& m_cache_entry_ptr) 875{ 876 m_cache_entry_ptr = 0; 877} 878''') 879 880 if self.TBEType != None: 881 code(''' 882 883// Set and Reset for tbe variable 884void 885$c_ident::set_tbe(${{self.TBEType.c_ident}}*& m_tbe_ptr, ${{self.TBEType.c_ident}}* m_new_tbe) 886{ 887 m_tbe_ptr = m_new_tbe; 888} 889 890void 891$c_ident::unset_tbe(${{self.TBEType.c_ident}}*& m_tbe_ptr) 892{ 893 m_tbe_ptr = NULL; 894} 895''') 896 897 code(''' 898 899void 900$c_ident::recordCacheTrace(int cntrl, CacheRecorder* tr) 901{ 902''') 903 # 904 # Record cache contents for all associated caches. 905 # 906 code.indent() 907 for param in self.config_parameters: 908 if param.type_ast.type.ident == "CacheMemory": 909 assert(param.pointer) 910 code('m_${{param.ident}}_ptr->recordCacheContents(cntrl, tr);') 911 912 code.dedent() 913 code(''' 914} 915 916// Actions 917''') 918 if self.TBEType != None and self.EntryType != None: 919 for action in self.actions.itervalues(): 920 if "c_code" not in action: 921 continue 922 923 code(''' 924/** \\brief ${{action.desc}} */ 925void 926$c_ident::${{action.ident}}(${{self.TBEType.c_ident}}*& m_tbe_ptr, ${{self.EntryType.c_ident}}*& m_cache_entry_ptr, const Address& addr) 927{ 928 DPRINTF(RubyGenerated, "executing ${{action.ident}}\\n"); 929 ${{action["c_code"]}} 930} 931 932''') 933 elif self.TBEType != None: 934 for action in self.actions.itervalues(): 935 if "c_code" not in action: 936 continue 937 938 code(''' 939/** \\brief ${{action.desc}} */ 940void 941$c_ident::${{action.ident}}(${{self.TBEType.c_ident}}*& m_tbe_ptr, const Address& addr) 942{ 943 DPRINTF(RubyGenerated, "executing ${{action.ident}}\\n"); 944 ${{action["c_code"]}} 945} 946 947''') 948 elif self.EntryType != None: 949 for action in self.actions.itervalues(): 950 if "c_code" not in action: 951 continue 952 953 code(''' 954/** \\brief ${{action.desc}} */ 955void 956$c_ident::${{action.ident}}(${{self.EntryType.c_ident}}*& m_cache_entry_ptr, const Address& addr) 957{ 958 DPRINTF(RubyGenerated, "executing ${{action.ident}}\\n"); 959 ${{action["c_code"]}} 960} 961 962''') 963 else: 964 for action in self.actions.itervalues(): 965 if "c_code" not in action: 966 continue 967 968 code(''' 969/** \\brief ${{action.desc}} */ 970void 971$c_ident::${{action.ident}}(const Address& addr) 972{ 973 DPRINTF(RubyGenerated, "executing ${{action.ident}}\\n"); 974 ${{action["c_code"]}} 975} 976 977''') 978 for func in self.functions: 979 code(func.generateCode()) 980 981 code.write(path, "%s.cc" % c_ident) 982 983 def printCWakeup(self, path): 984 '''Output the wakeup loop for the events''' 985 986 code = self.symtab.codeFormatter() 987 ident = self.ident 988 989 code(''' 990// Auto generated C++ code started by $__file__:$__line__ 991// ${ident}: ${{self.short}} 992 993#include <cassert> 994 995#include "base/misc.hh" 996#include "debug/RubySlicc.hh" 997#include "mem/protocol/${ident}_Controller.hh" 998#include "mem/protocol/${ident}_Event.hh" 999#include "mem/protocol/${ident}_State.hh" 1000#include "mem/protocol/Types.hh" 1001#include "mem/ruby/common/Global.hh" 1002#include "mem/ruby/slicc_interface/RubySlicc_includes.hh" 1003#include "mem/ruby/system/System.hh" 1004 1005using namespace std; 1006 1007void 1008${ident}_Controller::wakeup() 1009{ 1010 int counter = 0; 1011 while (true) { 1012 // Some cases will put us into an infinite loop without this limit 1013 assert(counter <= m_transitions_per_cycle); 1014 if (counter == m_transitions_per_cycle) { 1015 // Count how often we are fully utilized 1016 g_system_ptr->getProfiler()->controllerBusy(m_machineID); 1017 1018 // Wakeup in another cycle and try again 1019 g_eventQueue_ptr->scheduleEvent(this, 1); 1020 break; 1021 } 1022''') 1023 1024 code.indent() 1025 code.indent() 1026 1027 # InPorts 1028 # 1029 for port in self.in_ports: 1030 code.indent() 1031 code('// ${ident}InPort $port') 1032 if port.pairs.has_key("rank"): 1033 code('m_cur_in_port_rank = ${{port.pairs["rank"]}};') 1034 else: 1035 code('m_cur_in_port_rank = 0;') 1036 code('${{port["c_code_in_port"]}}') 1037 code.dedent() 1038 1039 code('') 1040 1041 code.dedent() 1042 code.dedent() 1043 code(''' 1044 break; // If we got this far, we have nothing left todo 1045 } 1046 // g_eventQueue_ptr->scheduleEvent(this, 1); 1047} 1048''') 1049 1050 code.write(path, "%s_Wakeup.cc" % self.ident) 1051 1052 def printCSwitch(self, path): 1053 '''Output switch statement for transition table''' 1054 1055 code = self.symtab.codeFormatter() 1056 ident = self.ident 1057 1058 code(''' 1059// Auto generated C++ code started by $__file__:$__line__ 1060// ${ident}: ${{self.short}} 1061 1062#include <cassert> 1063 1064#include "base/misc.hh" 1065#include "base/trace.hh" 1066#include "debug/ProtocolTrace.hh" 1067#include "debug/RubyGenerated.hh" 1068#include "mem/protocol/${ident}_Controller.hh" 1069#include "mem/protocol/${ident}_Event.hh" 1070#include "mem/protocol/${ident}_State.hh" 1071#include "mem/protocol/Types.hh" 1072#include "mem/ruby/common/Global.hh" 1073#include "mem/ruby/system/System.hh" 1074 1075#define HASH_FUN(state, event) ((int(state)*${ident}_Event_NUM)+int(event)) 1076 1077#define GET_TRANSITION_COMMENT() (${ident}_transitionComment.str()) 1078#define CLEAR_TRANSITION_COMMENT() (${ident}_transitionComment.str("")) 1079 1080TransitionResult 1081${ident}_Controller::doTransition(${ident}_Event event, 1082''') 1083 if self.EntryType != None: 1084 code(''' 1085 ${{self.EntryType.c_ident}}* m_cache_entry_ptr, 1086''') 1087 if self.TBEType != None: 1088 code(''' 1089 ${{self.TBEType.c_ident}}* m_tbe_ptr, 1090''') 1091 code(''' 1092 const Address &addr) 1093{ 1094''') 1095 if self.TBEType != None and self.EntryType != None: 1096 code('${ident}_State state = getState(m_tbe_ptr, m_cache_entry_ptr, addr);') 1097 elif self.TBEType != None: 1098 code('${ident}_State state = getState(m_tbe_ptr, addr);') 1099 elif self.EntryType != None: 1100 code('${ident}_State state = getState(m_cache_entry_ptr, addr);') 1101 else: 1102 code('${ident}_State state = getState(addr);') 1103 1104 code(''' 1105 ${ident}_State next_state = state; 1106 1107 DPRINTF(RubyGenerated, "%s, Time: %lld, state: %s, event: %s, addr: %s\\n", 1108 *this, 1109 g_eventQueue_ptr->getTime(), 1110 ${ident}_State_to_string(state), 1111 ${ident}_Event_to_string(event), 1112 addr); 1113 1114 TransitionResult result = 1115''') 1116 if self.TBEType != None and self.EntryType != None: 1117 code('doTransitionWorker(event, state, next_state, m_tbe_ptr, m_cache_entry_ptr, addr);') 1118 elif self.TBEType != None: 1119 code('doTransitionWorker(event, state, next_state, m_tbe_ptr, addr);') 1120 elif self.EntryType != None: 1121 code('doTransitionWorker(event, state, next_state, m_cache_entry_ptr, addr);') 1122 else: 1123 code('doTransitionWorker(event, state, next_state, addr);') 1124 1125 code(''' 1126 if (result == TransitionResult_Valid) { 1127 DPRINTF(RubyGenerated, "next_state: %s\\n", 1128 ${ident}_State_to_string(next_state)); 1129 m_profiler.countTransition(state, event); 1130 DPRINTFR(ProtocolTrace, "%15d %3s %10s%20s %6s>%-6s %s %s\\n", 1131 curTick(), m_version, "${ident}", 1132 ${ident}_Event_to_string(event), 1133 ${ident}_State_to_string(state), 1134 ${ident}_State_to_string(next_state), 1135 addr, GET_TRANSITION_COMMENT()); 1136 1137 CLEAR_TRANSITION_COMMENT(); 1138''') 1139 if self.TBEType != None and self.EntryType != None: 1140 code('setState(m_tbe_ptr, m_cache_entry_ptr, addr, next_state);') 1141 code('setAccessPermission(m_cache_entry_ptr, addr, next_state);') 1142 elif self.TBEType != None: 1143 code('setState(m_tbe_ptr, addr, next_state);') 1144 code('setAccessPermission(addr, next_state);') 1145 elif self.EntryType != None: 1146 code('setState(m_cache_entry_ptr, addr, next_state);') 1147 code('setAccessPermission(m_cache_entry_ptr, addr, next_state);') 1148 else: 1149 code('setState(addr, next_state);') 1150 code('setAccessPermission(addr, next_state);') 1151 1152 code(''' 1153 } else if (result == TransitionResult_ResourceStall) { 1154 DPRINTFR(ProtocolTrace, "%15s %3s %10s%20s %6s>%-6s %s %s\\n", 1155 curTick(), m_version, "${ident}", 1156 ${ident}_Event_to_string(event), 1157 ${ident}_State_to_string(state), 1158 ${ident}_State_to_string(next_state), 1159 addr, "Resource Stall"); 1160 } else if (result == TransitionResult_ProtocolStall) { 1161 DPRINTF(RubyGenerated, "stalling\\n"); 1162 DPRINTFR(ProtocolTrace, "%15s %3s %10s%20s %6s>%-6s %s %s\\n", 1163 curTick(), m_version, "${ident}", 1164 ${ident}_Event_to_string(event), 1165 ${ident}_State_to_string(state), 1166 ${ident}_State_to_string(next_state), 1167 addr, "Protocol Stall"); 1168 } 1169 1170 return result; 1171} 1172 1173TransitionResult 1174${ident}_Controller::doTransitionWorker(${ident}_Event event, 1175 ${ident}_State state, 1176 ${ident}_State& next_state, 1177''') 1178 1179 if self.TBEType != None: 1180 code(''' 1181 ${{self.TBEType.c_ident}}*& m_tbe_ptr, 1182''') 1183 if self.EntryType != None: 1184 code(''' 1185 ${{self.EntryType.c_ident}}*& m_cache_entry_ptr, 1186''') 1187 code(''' 1188 const Address& addr) 1189{ 1190 switch(HASH_FUN(state, event)) { 1191''') 1192 1193 # This map will allow suppress generating duplicate code 1194 cases = orderdict() 1195 1196 for trans in self.transitions: 1197 case_string = "%s_State_%s, %s_Event_%s" % \ 1198 (self.ident, trans.state.ident, self.ident, trans.event.ident) 1199 1200 case = self.symtab.codeFormatter() 1201 # Only set next_state if it changes 1202 if trans.state != trans.nextState: 1203 ns_ident = trans.nextState.ident 1204 case('next_state = ${ident}_State_${ns_ident};') 1205 1206 actions = trans.actions 1207 1208 # Check for resources 1209 case_sorter = [] 1210 res = trans.resources 1211 for key,val in res.iteritems(): 1212 if key.type.ident != "DNUCAStopTable": 1213 val = ''' 1214if (!%s.areNSlotsAvailable(%s)) 1215 return TransitionResult_ResourceStall; 1216''' % (key.code, val) 1217 case_sorter.append(val) 1218 1219 1220 # Emit the code sequences in a sorted order. This makes the 1221 # output deterministic (without this the output order can vary 1222 # since Map's keys() on a vector of pointers is not deterministic 1223 for c in sorted(case_sorter): 1224 case("$c") 1225 1226 # Figure out if we stall 1227 stall = False 1228 for action in actions: 1229 if action.ident == "z_stall": 1230 stall = True 1231 break 1232 1233 if stall: 1234 case('return TransitionResult_ProtocolStall;') 1235 else: 1236 if self.TBEType != None and self.EntryType != None: 1237 for action in actions: 1238 case('${{action.ident}}(m_tbe_ptr, m_cache_entry_ptr, addr);') 1239 elif self.TBEType != None: 1240 for action in actions: 1241 case('${{action.ident}}(m_tbe_ptr, addr);') 1242 elif self.EntryType != None: 1243 for action in actions: 1244 case('${{action.ident}}(m_cache_entry_ptr, addr);') 1245 else: 1246 for action in actions: 1247 case('${{action.ident}}(addr);') 1248 case('return TransitionResult_Valid;') 1249 1250 case = str(case) 1251 1252 # Look to see if this transition code is unique. 1253 if case not in cases: 1254 cases[case] = [] 1255 1256 cases[case].append(case_string) 1257 1258 # Walk through all of the unique code blocks and spit out the 1259 # corresponding case statement elements 1260 for case,transitions in cases.iteritems(): 1261 # Iterative over all the multiple transitions that share 1262 # the same code 1263 for trans in transitions: 1264 code(' case HASH_FUN($trans):') 1265 code(' $case') 1266 1267 code(''' 1268 default: 1269 fatal("Invalid transition\\n" 1270 "%s time: %d addr: %s event: %s state: %s\\n", 1271 name(), g_eventQueue_ptr->getTime(), addr, event, state); 1272 } 1273 return TransitionResult_Valid; 1274} 1275''') 1276 code.write(path, "%s_Transitions.cc" % self.ident) 1277 1278 def printProfileDumperHH(self, path): 1279 code = self.symtab.codeFormatter() 1280 ident = self.ident 1281 1282 code(''' 1283// Auto generated C++ code started by $__file__:$__line__ 1284// ${ident}: ${{self.short}} 1285 1286#ifndef __${ident}_PROFILE_DUMPER_HH__ 1287#define __${ident}_PROFILE_DUMPER_HH__ 1288 1289#include <cassert> 1290#include <iostream> 1291#include <vector> 1292 1293#include "${ident}_Event.hh" 1294#include "${ident}_Profiler.hh" 1295 1296typedef std::vector<${ident}_Profiler *> ${ident}_profilers; 1297 1298class ${ident}_ProfileDumper 1299{ 1300 public: 1301 ${ident}_ProfileDumper(); 1302 void registerProfiler(${ident}_Profiler* profiler); 1303 void dumpStats(std::ostream& out) const; 1304 1305 private: 1306 ${ident}_profilers m_profilers; 1307}; 1308 1309#endif // __${ident}_PROFILE_DUMPER_HH__ 1310''') 1311 code.write(path, "%s_ProfileDumper.hh" % self.ident) 1312 1313 def printProfileDumperCC(self, path): 1314 code = self.symtab.codeFormatter() 1315 ident = self.ident 1316 1317 code(''' 1318// Auto generated C++ code started by $__file__:$__line__ 1319// ${ident}: ${{self.short}} 1320 1321#include "mem/protocol/${ident}_ProfileDumper.hh" 1322 1323${ident}_ProfileDumper::${ident}_ProfileDumper() 1324{ 1325} 1326 1327void 1328${ident}_ProfileDumper::registerProfiler(${ident}_Profiler* profiler) 1329{ 1330 m_profilers.push_back(profiler); 1331} 1332 1333void 1334${ident}_ProfileDumper::dumpStats(std::ostream& out) const 1335{ 1336 out << " --- ${ident} ---\\n"; 1337 out << " - Event Counts -\\n"; 1338 for (${ident}_Event event = ${ident}_Event_FIRST; 1339 event < ${ident}_Event_NUM; 1340 ++event) { 1341 out << (${ident}_Event) event << " ["; 1342 uint64 total = 0; 1343 for (int i = 0; i < m_profilers.size(); i++) { 1344 out << m_profilers[i]->getEventCount(event) << " "; 1345 total += m_profilers[i]->getEventCount(event); 1346 } 1347 out << "] " << total << "\\n"; 1348 } 1349 out << "\\n"; 1350 out << " - Transitions -\\n"; 1351 for (${ident}_State state = ${ident}_State_FIRST; 1352 state < ${ident}_State_NUM; 1353 ++state) { 1354 for (${ident}_Event event = ${ident}_Event_FIRST; 1355 event < ${ident}_Event_NUM; 1356 ++event) { 1357 if (m_profilers[0]->isPossible(state, event)) { 1358 out << (${ident}_State) state << " " 1359 << (${ident}_Event) event << " ["; 1360 uint64 total = 0; 1361 for (int i = 0; i < m_profilers.size(); i++) { 1362 out << m_profilers[i]->getTransitionCount(state, event) << " "; 1363 total += m_profilers[i]->getTransitionCount(state, event); 1364 } 1365 out << "] " << total << "\\n"; 1366 } 1367 } 1368 out << "\\n"; 1369 } 1370} 1371''') 1372 code.write(path, "%s_ProfileDumper.cc" % self.ident) 1373 1374 def printProfilerHH(self, path): 1375 code = self.symtab.codeFormatter() 1376 ident = self.ident 1377 1378 code(''' 1379// Auto generated C++ code started by $__file__:$__line__ 1380// ${ident}: ${{self.short}} 1381 1382#ifndef __${ident}_PROFILER_HH__ 1383#define __${ident}_PROFILER_HH__ 1384 1385#include <cassert> 1386#include <iostream> 1387 1388#include "mem/protocol/${ident}_Event.hh" 1389#include "mem/protocol/${ident}_State.hh" 1390#include "mem/ruby/common/TypeDefines.hh" 1391 1392class ${ident}_Profiler 1393{ 1394 public: 1395 ${ident}_Profiler(); 1396 void setVersion(int version); 1397 void countTransition(${ident}_State state, ${ident}_Event event); 1398 void possibleTransition(${ident}_State state, ${ident}_Event event); 1399 uint64 getEventCount(${ident}_Event event); 1400 bool isPossible(${ident}_State state, ${ident}_Event event); 1401 uint64 getTransitionCount(${ident}_State state, ${ident}_Event event); 1402 void clearStats(); 1403 1404 private: 1405 int m_counters[${ident}_State_NUM][${ident}_Event_NUM]; 1406 int m_event_counters[${ident}_Event_NUM]; 1407 bool m_possible[${ident}_State_NUM][${ident}_Event_NUM]; 1408 int m_version; 1409}; 1410 1411#endif // __${ident}_PROFILER_HH__ 1412''') 1413 code.write(path, "%s_Profiler.hh" % self.ident) 1414 1415 def printProfilerCC(self, path): 1416 code = self.symtab.codeFormatter() 1417 ident = self.ident 1418 1419 code(''' 1420// Auto generated C++ code started by $__file__:$__line__ 1421// ${ident}: ${{self.short}} 1422 1423#include <cassert> 1424 1425#include "mem/protocol/${ident}_Profiler.hh" 1426 1427${ident}_Profiler::${ident}_Profiler() 1428{ 1429 for (int state = 0; state < ${ident}_State_NUM; state++) { 1430 for (int event = 0; event < ${ident}_Event_NUM; event++) { 1431 m_possible[state][event] = false; 1432 m_counters[state][event] = 0; 1433 } 1434 } 1435 for (int event = 0; event < ${ident}_Event_NUM; event++) { 1436 m_event_counters[event] = 0; 1437 } 1438} 1439 1440void 1441${ident}_Profiler::setVersion(int version) 1442{ 1443 m_version = version; 1444} 1445 1446void 1447${ident}_Profiler::clearStats() 1448{ 1449 for (int state = 0; state < ${ident}_State_NUM; state++) { 1450 for (int event = 0; event < ${ident}_Event_NUM; event++) { 1451 m_counters[state][event] = 0; 1452 } 1453 } 1454 1455 for (int event = 0; event < ${ident}_Event_NUM; event++) { 1456 m_event_counters[event] = 0; 1457 } 1458} 1459void 1460${ident}_Profiler::countTransition(${ident}_State state, ${ident}_Event event) 1461{ 1462 assert(m_possible[state][event]); 1463 m_counters[state][event]++; 1464 m_event_counters[event]++; 1465} 1466void 1467${ident}_Profiler::possibleTransition(${ident}_State state, 1468 ${ident}_Event event) 1469{ 1470 m_possible[state][event] = true; 1471} 1472 1473uint64 1474${ident}_Profiler::getEventCount(${ident}_Event event) 1475{ 1476 return m_event_counters[event]; 1477} 1478 1479bool 1480${ident}_Profiler::isPossible(${ident}_State state, ${ident}_Event event) 1481{ 1482 return m_possible[state][event]; 1483} 1484 1485uint64 1486${ident}_Profiler::getTransitionCount(${ident}_State state, 1487 ${ident}_Event event) 1488{ 1489 return m_counters[state][event]; 1490} 1491 1492''') 1493 code.write(path, "%s_Profiler.cc" % self.ident) 1494 1495 # ************************** 1496 # ******* HTML Files ******* 1497 # ************************** 1498 def frameRef(self, click_href, click_target, over_href, over_num, text): 1499 code = self.symtab.codeFormatter(fix_newlines=False) 1500 code("""<A href=\"$click_href\" target=\"$click_target\" onmouseover=\" 1501 if (parent.frames[$over_num].location != parent.location + '$over_href') { 1502 parent.frames[$over_num].location='$over_href' 1503 }\"> 1504 ${{html.formatShorthand(text)}} 1505 </A>""") 1506 return str(code) 1507 1508 def writeHTMLFiles(self, path): 1509 # Create table with no row hilighted 1510 self.printHTMLTransitions(path, None) 1511 1512 # Generate transition tables 1513 for state in self.states.itervalues(): 1514 self.printHTMLTransitions(path, state) 1515 1516 # Generate action descriptions 1517 for action in self.actions.itervalues(): 1518 name = "%s_action_%s.html" % (self.ident, action.ident) 1519 code = html.createSymbol(action, "Action") 1520 code.write(path, name) 1521 1522 # Generate state descriptions 1523 for state in self.states.itervalues(): 1524 name = "%s_State_%s.html" % (self.ident, state.ident) 1525 code = html.createSymbol(state, "State") 1526 code.write(path, name) 1527 1528 # Generate event descriptions 1529 for event in self.events.itervalues(): 1530 name = "%s_Event_%s.html" % (self.ident, event.ident) 1531 code = html.createSymbol(event, "Event") 1532 code.write(path, name) 1533 1534 def printHTMLTransitions(self, path, active_state): 1535 code = self.symtab.codeFormatter() 1536 1537 code(''' 1538<HTML> 1539<BODY link="blue" vlink="blue"> 1540 1541<H1 align="center">${{html.formatShorthand(self.short)}}: 1542''') 1543 code.indent() 1544 for i,machine in enumerate(self.symtab.getAllType(StateMachine)): 1545 mid = machine.ident 1546 if i != 0: 1547 extra = " - " 1548 else: 1549 extra = "" 1550 if machine == self: 1551 code('$extra$mid') 1552 else: 1553 code('$extra<A target="Table" href="${mid}_table.html">$mid</A>') 1554 code.dedent() 1555 1556 code(""" 1557</H1> 1558 1559<TABLE border=1> 1560<TR> 1561 <TH> </TH> 1562""") 1563 1564 for event in self.events.itervalues(): 1565 href = "%s_Event_%s.html" % (self.ident, event.ident) 1566 ref = self.frameRef(href, "Status", href, "1", event.short) 1567 code('<TH bgcolor=white>$ref</TH>') 1568 1569 code('</TR>') 1570 # -- Body of table 1571 for state in self.states.itervalues(): 1572 # -- Each row 1573 if state == active_state: 1574 color = "yellow" 1575 else: 1576 color = "white" 1577 1578 click = "%s_table_%s.html" % (self.ident, state.ident) 1579 over = "%s_State_%s.html" % (self.ident, state.ident) 1580 text = html.formatShorthand(state.short) 1581 ref = self.frameRef(click, "Table", over, "1", state.short) 1582 code(''' 1583<TR> 1584 <TH bgcolor=$color>$ref</TH> 1585''') 1586 1587 # -- One column for each event 1588 for event in self.events.itervalues(): 1589 trans = self.table.get((state,event), None) 1590 if trans is None: 1591 # This is the no transition case 1592 if state == active_state: 1593 color = "#C0C000" 1594 else: 1595 color = "lightgrey" 1596 1597 code('<TD bgcolor=$color> </TD>') 1598 continue 1599 1600 next = trans.nextState 1601 stall_action = False 1602 1603 # -- Get the actions 1604 for action in trans.actions: 1605 if action.ident == "z_stall" or \ 1606 action.ident == "zz_recycleMandatoryQueue": 1607 stall_action = True 1608 1609 # -- Print out "actions/next-state" 1610 if stall_action: 1611 if state == active_state: 1612 color = "#C0C000" 1613 else: 1614 color = "lightgrey" 1615 1616 elif active_state and next.ident == active_state.ident: 1617 color = "aqua" 1618 elif state == active_state: 1619 color = "yellow" 1620 else: 1621 color = "white" 1622 1623 code('<TD bgcolor=$color>') 1624 for action in trans.actions: 1625 href = "%s_action_%s.html" % (self.ident, action.ident) 1626 ref = self.frameRef(href, "Status", href, "1", 1627 action.short) 1628 code(' $ref') 1629 if next != state: 1630 if trans.actions: 1631 code('/') 1632 click = "%s_table_%s.html" % (self.ident, next.ident) 1633 over = "%s_State_%s.html" % (self.ident, next.ident) 1634 ref = self.frameRef(click, "Table", over, "1", next.short) 1635 code("$ref") 1636 code("</TD>") 1637 1638 # -- Each row 1639 if state == active_state: 1640 color = "yellow" 1641 else: 1642 color = "white" 1643 1644 click = "%s_table_%s.html" % (self.ident, state.ident) 1645 over = "%s_State_%s.html" % (self.ident, state.ident) 1646 ref = self.frameRef(click, "Table", over, "1", state.short) 1647 code(''' 1648 <TH bgcolor=$color>$ref</TH> 1649</TR> 1650''') 1651 code(''' 1652<!- Column footer-> 1653<TR> 1654 <TH> </TH> 1655''') 1656 1657 for event in self.events.itervalues(): 1658 href = "%s_Event_%s.html" % (self.ident, event.ident) 1659 ref = self.frameRef(href, "Status", href, "1", event.short) 1660 code('<TH bgcolor=white>$ref</TH>') 1661 code(''' 1662</TR> 1663</TABLE> 1664</BODY></HTML> 1665''') 1666 1667 1668 if active_state: 1669 name = "%s_table_%s.html" % (self.ident, active_state.ident) 1670 else: 1671 name = "%s_table.html" % self.ident 1672 code.write(path, name) 1673 1674__all__ = [ "StateMachine" ] 1675