StateMachine.py revision 7025:9adf5b0ccc79
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 33 34python_class_map = {"int": "Int", 35 "string": "String", 36 "bool": "Bool", 37 "CacheMemory": "RubyCache", 38 "Sequencer": "RubySequencer", 39 "DirectoryMemory": "RubyDirectoryMemory", 40 "MemoryControl": "RubyMemoryControl", 41 "DMASequencer": "DMASequencer" 42 } 43 44class StateMachine(Symbol): 45 def __init__(self, symtab, ident, location, pairs, config_parameters): 46 super(StateMachine, self).__init__(symtab, ident, location, pairs) 47 self.table = None 48 self.config_parameters = config_parameters 49 for param in config_parameters: 50 if param.pointer: 51 var = Var(symtab, param.name, location, param.type_ast.type, 52 "(*m_%s_ptr)" % param.name, {}, self) 53 else: 54 var = Var(symtab, param.name, location, param.type_ast.type, 55 "m_%s" % param.name, {}, self) 56 self.symtab.registerSym(param.name, var) 57 58 self.states = orderdict() 59 self.events = orderdict() 60 self.actions = orderdict() 61 self.transitions = [] 62 self.in_ports = [] 63 self.functions = [] 64 self.objects = [] 65 66 self.message_buffer_names = [] 67 68 def __repr__(self): 69 return "[StateMachine: %s]" % self.ident 70 71 def addState(self, state): 72 assert self.table is None 73 self.states[state.ident] = state 74 75 def addEvent(self, event): 76 assert self.table is None 77 self.events[event.ident] = event 78 79 def addAction(self, action): 80 assert self.table is None 81 82 # Check for duplicate action 83 for other in self.actions.itervalues(): 84 if action.ident == other.ident: 85 action.warning("Duplicate action definition: %s" % action.ident) 86 action.error("Duplicate action definition: %s" % action.ident) 87 if action.short == other.short: 88 other.warning("Duplicate action shorthand: %s" % other.ident) 89 other.warning(" shorthand = %s" % other.short) 90 action.warning("Duplicate action shorthand: %s" % action.ident) 91 action.error(" shorthand = %s" % action.short) 92 93 self.actions[action.ident] = action 94 95 def addTransition(self, trans): 96 assert self.table is None 97 self.transitions.append(trans) 98 99 def addInPort(self, var): 100 self.in_ports.append(var) 101 102 def addFunc(self, func): 103 # register func in the symbol table 104 self.symtab.registerSym(str(func), func) 105 self.functions.append(func) 106 107 def addObject(self, obj): 108 self.objects.append(obj) 109 110 # Needs to be called before accessing the table 111 def buildTable(self): 112 assert self.table is None 113 114 table = {} 115 116 for trans in self.transitions: 117 # Track which actions we touch so we know if we use them 118 # all -- really this should be done for all symbols as 119 # part of the symbol table, then only trigger it for 120 # Actions, States, Events, etc. 121 122 for action in trans.actions: 123 action.used = True 124 125 index = (trans.state, trans.event) 126 if index in table: 127 table[index].warning("Duplicate transition: %s" % table[index]) 128 trans.error("Duplicate transition: %s" % trans) 129 table[index] = trans 130 131 # Look at all actions to make sure we used them all 132 for action in self.actions.itervalues(): 133 if not action.used: 134 error_msg = "Unused action: %s" % action.ident 135 if "desc" in action: 136 error_msg += ", " + action.desc 137 action.warning(error_msg) 138 self.table = table 139 140 def writeCodeFiles(self, path): 141 self.printControllerPython(path) 142 self.printControllerHH(path) 143 self.printControllerCC(path) 144 self.printCSwitch(path) 145 self.printCWakeup(path) 146 self.printProfilerCC(path) 147 self.printProfilerHH(path) 148 149 for func in self.functions: 150 func.writeCodeFiles(path) 151 152 def printControllerPython(self, path): 153 code = self.symtab.codeFormatter() 154 ident = self.ident 155 py_ident = "%s_Controller" % ident 156 c_ident = "%s_Controller" % self.ident 157 code(''' 158from m5.params import * 159from m5.SimObject import SimObject 160from Controller import RubyController 161 162class $py_ident(RubyController): 163 type = '$py_ident' 164''') 165 code.indent() 166 for param in self.config_parameters: 167 dflt_str = '' 168 if param.default is not None: 169 dflt_str = str(param.default) + ', ' 170 if python_class_map.has_key(param.type_ast.type.c_ident): 171 python_type = python_class_map[param.type_ast.type.c_ident] 172 code('${{param.name}} = Param.${{python_type}}(${dflt_str}"")') 173 else: 174 self.error("Unknown c++ to python class conversion for c++ " \ 175 "type: '%s'. Please update the python_class_map " \ 176 "in StateMachine.py", param.type_ast.type.c_ident) 177 code.dedent() 178 code.write(path, '%s.py' % py_ident) 179 180 181 def printControllerHH(self, path): 182 '''Output the method declarations for the class declaration''' 183 code = self.symtab.codeFormatter() 184 ident = self.ident 185 c_ident = "%s_Controller" % self.ident 186 187 self.message_buffer_names = [] 188 189 code(''' 190/** \\file $c_ident.hh 191 * 192 * Auto generated C++ code started by $__file__:$__line__ 193 * Created by slicc definition of Module "${{self.short}}" 194 */ 195 196#ifndef __${ident}_CONTROLLER_HH__ 197#define __${ident}_CONTROLLER_HH__ 198 199#include <iostream> 200#include <sstream> 201#include <string> 202 203#include "params/$c_ident.hh" 204 205#include "mem/ruby/common/Global.hh" 206#include "mem/ruby/common/Consumer.hh" 207#include "mem/ruby/slicc_interface/AbstractController.hh" 208#include "mem/protocol/TransitionResult.hh" 209#include "mem/protocol/Types.hh" 210#include "mem/protocol/${ident}_Profiler.hh" 211''') 212 213 seen_types = set() 214 for var in self.objects: 215 if var.type.ident not in seen_types and not var.type.isPrimitive: 216 code('#include "mem/protocol/${{var.type.c_ident}}.hh"') 217 seen_types.add(var.type.ident) 218 219 # for adding information to the protocol debug trace 220 code(''' 221extern std::stringstream ${ident}_transitionComment; 222 223class $c_ident : public AbstractController 224{ 225// the coherence checker needs to call isBlockExclusive() and isBlockShared() 226// making the Chip a friend class is an easy way to do this for now 227 228public: 229 typedef ${c_ident}Params Params; 230 $c_ident(const Params *p); 231 static int getNumControllers(); 232 void init(); 233 MessageBuffer* getMandatoryQueue() const; 234 const int & getVersion() const; 235 const std::string toString() const; 236 const std::string getName() const; 237 const MachineType getMachineType() const; 238 void initNetworkPtr(Network* net_ptr) { m_net_ptr = net_ptr; } 239 void print(std::ostream& out) const; 240 void printConfig(std::ostream& out) const; 241 void wakeup(); 242 void printStats(std::ostream& out) const; 243 void clearStats(); 244 void blockOnQueue(Address addr, MessageBuffer* port); 245 void unblock(Address addr); 246 247private: 248''') 249 250 code.indent() 251 # added by SS 252 for param in self.config_parameters: 253 if param.pointer: 254 code('${{param.type_ast.type}}* m_${{param.ident}}_ptr;') 255 else: 256 code('${{param.type_ast.type}} m_${{param.ident}};') 257 258 code(''' 259int m_number_of_TBEs; 260 261TransitionResult doTransition(${ident}_Event event, 262 ${ident}_State state, 263 const Address& addr); 264 265TransitionResult doTransitionWorker(${ident}_Event event, 266 ${ident}_State state, 267 ${ident}_State& next_state, 268 const Address& addr); 269 270std::string m_name; 271int m_transitions_per_cycle; 272int m_buffer_size; 273int m_recycle_latency; 274map<std::string, std::string> m_cfg; 275NodeID m_version; 276Network* m_net_ptr; 277MachineID m_machineID; 278bool m_is_blocking; 279map< Address, MessageBuffer* > m_block_map; 280${ident}_Profiler s_profiler; 281static int m_num_controllers; 282 283// Internal functions 284''') 285 286 for func in self.functions: 287 proto = func.prototype 288 if proto: 289 code('$proto') 290 291 code(''' 292 293// Actions 294''') 295 for action in self.actions.itervalues(): 296 code('/** \\brief ${{action.desc}} */') 297 code('void ${{action.ident}}(const Address& addr);') 298 299 # the controller internal variables 300 code(''' 301 302// Objects 303''') 304 for var in self.objects: 305 th = var.get("template_hack", "") 306 code('${{var.type.c_ident}}$th* m_${{var.c_ident}}_ptr;') 307 308 if var.type.ident == "MessageBuffer": 309 self.message_buffer_names.append("m_%s_ptr" % var.c_ident) 310 311 code.dedent() 312 code('};') 313 code('#endif // __${ident}_CONTROLLER_H__') 314 code.write(path, '%s.hh' % c_ident) 315 316 def printControllerCC(self, path): 317 '''Output the actions for performing the actions''' 318 319 code = self.symtab.codeFormatter() 320 ident = self.ident 321 c_ident = "%s_Controller" % self.ident 322 323 code(''' 324/** \\file $c_ident.cc 325 * 326 * Auto generated C++ code started by $__file__:$__line__ 327 * Created by slicc definition of Module "${{self.short}}" 328 */ 329 330#include <sstream> 331#include <string> 332 333#include "mem/ruby/common/Global.hh" 334#include "mem/ruby/slicc_interface/RubySlicc_includes.hh" 335#include "mem/protocol/${ident}_Controller.hh" 336#include "mem/protocol/${ident}_State.hh" 337#include "mem/protocol/${ident}_Event.hh" 338#include "mem/protocol/Types.hh" 339#include "mem/ruby/system/System.hh" 340 341using namespace std; 342''') 343 344 # include object classes 345 seen_types = set() 346 for var in self.objects: 347 if var.type.ident not in seen_types and not var.type.isPrimitive: 348 code('#include "mem/protocol/${{var.type.c_ident}}.hh"') 349 seen_types.add(var.type.ident) 350 351 code(''' 352$c_ident * 353${c_ident}Params::create() 354{ 355 return new $c_ident(this); 356} 357 358int $c_ident::m_num_controllers = 0; 359 360// for adding information to the protocol debug trace 361stringstream ${ident}_transitionComment; 362#define APPEND_TRANSITION_COMMENT(str) (${ident}_transitionComment << str) 363 364/** \\brief constructor */ 365$c_ident::$c_ident(const Params *p) 366 : AbstractController(p) 367{ 368 m_version = p->version; 369 m_transitions_per_cycle = p->transitions_per_cycle; 370 m_buffer_size = p->buffer_size; 371 m_recycle_latency = p->recycle_latency; 372 m_number_of_TBEs = p->number_of_TBEs; 373 m_is_blocking = false; 374''') 375 code.indent() 376 377 # 378 # After initializing the universal machine parameters, initialize the 379 # this machines config parameters. Also detemine if these configuration 380 # params include a sequencer. This information will be used later for 381 # contecting the sequencer back to the L1 cache controller. 382 # 383 contains_sequencer = False 384 for param in self.config_parameters: 385 if param.name == "sequencer" or param.name == "dma_sequencer": 386 contains_sequencer = True 387 if param.pointer: 388 code('m_${{param.name}}_ptr = p->${{param.name}};') 389 else: 390 code('m_${{param.name}} = p->${{param.name}};') 391 392 # 393 # For the l1 cache controller, add the special atomic support which 394 # includes passing the sequencer a pointer to the controller. 395 # 396 if self.ident == "L1Cache": 397 if not contains_sequencer: 398 self.error("The L1Cache controller must include the sequencer " \ 399 "configuration parameter") 400 401 code(''' 402m_sequencer_ptr->setController(this); 403''') 404 # 405 # For the DMA controller, pass the sequencer a pointer to the 406 # controller. 407 # 408 if self.ident == "DMA": 409 if not contains_sequencer: 410 self.error("The DMA controller must include the sequencer " \ 411 "configuration parameter") 412 413 code(''' 414m_dma_sequencer_ptr->setController(this); 415''') 416 417 code('m_num_controllers++;') 418 for var in self.objects: 419 if var.ident.find("mandatoryQueue") >= 0: 420 code('m_${{var.c_ident}}_ptr = new ${{var.type.c_ident}}();') 421 422 code.dedent() 423 code(''' 424} 425 426void 427$c_ident::init() 428{ 429 MachineType machine_type; 430 int base; 431 432 m_machineID.type = MachineType_${ident}; 433 m_machineID.num = m_version; 434 435 // initialize objects 436 s_profiler.setVersion(m_version); 437 438''') 439 440 code.indent() 441 for var in self.objects: 442 vtype = var.type 443 vid = "m_%s_ptr" % var.c_ident 444 if "network" not in var: 445 # Not a network port object 446 if "primitive" in vtype: 447 code('$vid = new ${{vtype.c_ident}};') 448 if "default" in var: 449 code('(*$vid) = ${{var["default"]}};') 450 else: 451 # Normal Object 452 # added by SS 453 if "factory" in var: 454 code('$vid = ${{var["factory"]}};') 455 elif var.ident.find("mandatoryQueue") < 0: 456 th = var.get("template_hack", "") 457 expr = "%s = new %s%s" % (vid, vtype.c_ident, th) 458 459 args = "" 460 if "non_obj" not in vtype and not vtype.isEnumeration: 461 if expr.find("TBETable") >= 0: 462 args = "m_number_of_TBEs" 463 else: 464 args = var.get("constructor_hack", "") 465 466 code('$expr($args);') 467 468 code('assert($vid != NULL);') 469 470 if "default" in var: 471 code('*$vid = ${{var["default"]}}; // Object default') 472 elif "default" in vtype: 473 comment = "Type %s default" % vtype.ident 474 code('*$vid = ${{vtype["default"]}}; // $comment') 475 476 # Set ordering 477 if "ordered" in var and "trigger_queue" not in var: 478 # A buffer 479 code('$vid->setOrdering(${{var["ordered"]}});') 480 481 # Set randomization 482 if "random" in var: 483 # A buffer 484 code('$vid->setRandomization(${{var["random"]}});') 485 486 # Set Priority 487 if vtype.isBuffer and \ 488 "rank" in var and "trigger_queue" not in var: 489 code('$vid->setPriority(${{var["rank"]}});') 490 else: 491 # Network port object 492 network = var["network"] 493 ordered = var["ordered"] 494 vnet = var["virtual_network"] 495 496 assert var.machine is not None 497 code(''' 498machine_type = string_to_MachineType("${{var.machine.ident}}"); 499base = MachineType_base_number(machine_type); 500$vid = m_net_ptr->get${network}NetQueue(m_version + base, $ordered, $vnet); 501''') 502 503 code('assert($vid != NULL);') 504 505 # Set ordering 506 if "ordered" in var: 507 # A buffer 508 code('$vid->setOrdering(${{var["ordered"]}});') 509 510 # Set randomization 511 if "random" in var: 512 # A buffer 513 code('$vid->setRandomization(${{var["random"]}})') 514 515 # Set Priority 516 if "rank" in var: 517 code('$vid->setPriority(${{var["rank"]}})') 518 519 # Set buffer size 520 if vtype.isBuffer: 521 code(''' 522if (m_buffer_size > 0) { 523 $vid->setSize(m_buffer_size); 524} 525''') 526 527 # set description (may be overriden later by port def) 528 code(''' 529$vid->setDescription("[Version " + int_to_string(m_version) + ", ${ident}, name=${{var.c_ident}}]"); 530 531''') 532 533 # Set the queue consumers 534 code.insert_newline() 535 for port in self.in_ports: 536 code('${{port.code}}.setConsumer(this);') 537 538 # Set the queue descriptions 539 code.insert_newline() 540 for port in self.in_ports: 541 code('${{port.code}}.setDescription("[Version " + int_to_string(m_version) + ", $ident, $port]");') 542 543 # Initialize the transition profiling 544 code.insert_newline() 545 for trans in self.transitions: 546 # Figure out if we stall 547 stall = False 548 for action in trans.actions: 549 if action.ident == "z_stall": 550 stall = True 551 552 # Only possible if it is not a 'z' case 553 if not stall: 554 state = "%s_State_%s" % (self.ident, trans.state.ident) 555 event = "%s_Event_%s" % (self.ident, trans.event.ident) 556 code('s_profiler.possibleTransition($state, $event);') 557 558 # added by SS to initialize recycle_latency of message buffers 559 for buf in self.message_buffer_names: 560 code("$buf->setRecycleLatency(m_recycle_latency);") 561 562 code.dedent() 563 code('}') 564 565 has_mandatory_q = False 566 for port in self.in_ports: 567 if port.code.find("mandatoryQueue_ptr") >= 0: 568 has_mandatory_q = True 569 570 if has_mandatory_q: 571 mq_ident = "m_%s_mandatoryQueue_ptr" % self.ident 572 else: 573 mq_ident = "NULL" 574 575 code(''' 576int 577$c_ident::getNumControllers() 578{ 579 return m_num_controllers; 580} 581 582MessageBuffer* 583$c_ident::getMandatoryQueue() const 584{ 585 return $mq_ident; 586} 587 588const int & 589$c_ident::getVersion() const 590{ 591 return m_version; 592} 593 594const string 595$c_ident::toString() const 596{ 597 return "$c_ident"; 598} 599 600const string 601$c_ident::getName() const 602{ 603 return m_name; 604} 605 606const MachineType 607$c_ident::getMachineType() const 608{ 609 return MachineType_${ident}; 610} 611 612void 613$c_ident::blockOnQueue(Address addr, MessageBuffer* port) 614{ 615 m_is_blocking = true; 616 m_block_map[addr] = port; 617} 618 619void 620$c_ident::unblock(Address addr) 621{ 622 m_block_map.erase(addr); 623 if (m_block_map.size() == 0) { 624 m_is_blocking = false; 625 } 626} 627 628void 629$c_ident::print(ostream& out) const 630{ 631 out << "[$c_ident " << m_version << "]"; 632} 633 634void 635$c_ident::printConfig(ostream& out) const 636{ 637 out << "$c_ident config: " << m_name << endl; 638 out << " version: " << m_version << endl; 639 map<string, string>::const_iterator it; 640 for (it = m_cfg.begin(); it != m_cfg.end(); it++) 641 out << " " << it->first << ": " << it->second << endl; 642} 643 644void 645$c_ident::printStats(ostream& out) const 646{ 647''') 648 # 649 # Cache and Memory Controllers have specific profilers associated with 650 # them. Print out these stats before dumping state transition stats. 651 # 652 for param in self.config_parameters: 653 if param.type_ast.type.ident == "CacheMemory" or \ 654 param.type_ast.type.ident == "DirectoryMemory" or \ 655 param.type_ast.type.ident == "MemoryControl": 656 assert(param.pointer) 657 code(' m_${{param.ident}}_ptr->printStats(out);') 658 659 code(''' 660 s_profiler.dumpStats(out); 661} 662 663void $c_ident::clearStats() { 664''') 665 # 666 # Cache and Memory Controllers have specific profilers associated with 667 # them. These stats must be cleared too. 668 # 669 for param in self.config_parameters: 670 if param.type_ast.type.ident == "CacheMemory" or \ 671 param.type_ast.type.ident == "MemoryControl": 672 assert(param.pointer) 673 code(' m_${{param.ident}}_ptr->clearStats();') 674 675 code(''' 676 s_profiler.clearStats(); 677} 678 679// Actions 680''') 681 682 for action in self.actions.itervalues(): 683 if "c_code" not in action: 684 continue 685 686 code(''' 687/** \\brief ${{action.desc}} */ 688void 689$c_ident::${{action.ident}}(const Address& addr) 690{ 691 DEBUG_MSG(GENERATED_COMP, HighPrio, "executing"); 692 ${{action["c_code"]}} 693} 694 695''') 696 code.write(path, "%s.cc" % c_ident) 697 698 def printCWakeup(self, path): 699 '''Output the wakeup loop for the events''' 700 701 code = self.symtab.codeFormatter() 702 ident = self.ident 703 704 code(''' 705// Auto generated C++ code started by $__file__:$__line__ 706// ${ident}: ${{self.short}} 707 708#include "base/misc.hh" 709#include "mem/ruby/common/Global.hh" 710#include "mem/ruby/slicc_interface/RubySlicc_includes.hh" 711#include "mem/protocol/${ident}_Controller.hh" 712#include "mem/protocol/${ident}_State.hh" 713#include "mem/protocol/${ident}_Event.hh" 714#include "mem/protocol/Types.hh" 715#include "mem/ruby/system/System.hh" 716 717void 718${ident}_Controller::wakeup() 719{ 720 // DEBUG_EXPR(GENERATED_COMP, MedPrio, *this); 721 // DEBUG_EXPR(GENERATED_COMP, MedPrio, g_eventQueue_ptr->getTime()); 722 723 int counter = 0; 724 while (true) { 725 // Some cases will put us into an infinite loop without this limit 726 assert(counter <= m_transitions_per_cycle); 727 if (counter == m_transitions_per_cycle) { 728 // Count how often we are fully utilized 729 g_system_ptr->getProfiler()->controllerBusy(m_machineID); 730 731 // Wakeup in another cycle and try again 732 g_eventQueue_ptr->scheduleEvent(this, 1); 733 break; 734 } 735''') 736 737 code.indent() 738 code.indent() 739 740 # InPorts 741 # 742 for port in self.in_ports: 743 code.indent() 744 code('// ${ident}InPort $port') 745 code('${{port["c_code_in_port"]}}') 746 code.dedent() 747 748 code('') 749 750 code.dedent() 751 code.dedent() 752 code(''' 753 break; // If we got this far, we have nothing left todo 754 } 755 // g_eventQueue_ptr->scheduleEvent(this, 1); 756 // DEBUG_NEWLINE(GENERATED_COMP, MedPrio); 757} 758''') 759 760 code.write(path, "%s_Wakeup.cc" % self.ident) 761 762 def printCSwitch(self, path): 763 '''Output switch statement for transition table''' 764 765 code = self.symtab.codeFormatter() 766 ident = self.ident 767 768 code(''' 769// Auto generated C++ code started by $__file__:$__line__ 770// ${ident}: ${{self.short}} 771 772#include "mem/ruby/common/Global.hh" 773#include "mem/protocol/${ident}_Controller.hh" 774#include "mem/protocol/${ident}_State.hh" 775#include "mem/protocol/${ident}_Event.hh" 776#include "mem/protocol/Types.hh" 777#include "mem/ruby/system/System.hh" 778 779#define HASH_FUN(state, event) ((int(state)*${ident}_Event_NUM)+int(event)) 780 781#define GET_TRANSITION_COMMENT() (${ident}_transitionComment.str()) 782#define CLEAR_TRANSITION_COMMENT() (${ident}_transitionComment.str("")) 783 784TransitionResult 785${ident}_Controller::doTransition(${ident}_Event event, 786 ${ident}_State state, 787 const Address &addr) 788{ 789 ${ident}_State next_state = state; 790 791 DEBUG_NEWLINE(GENERATED_COMP, MedPrio); 792 DEBUG_MSG(GENERATED_COMP, MedPrio, *this); 793 DEBUG_EXPR(GENERATED_COMP, MedPrio, g_eventQueue_ptr->getTime()); 794 DEBUG_EXPR(GENERATED_COMP, MedPrio,state); 795 DEBUG_EXPR(GENERATED_COMP, MedPrio,event); 796 DEBUG_EXPR(GENERATED_COMP, MedPrio,addr); 797 798 TransitionResult result = 799 doTransitionWorker(event, state, next_state, addr); 800 801 if (result == TransitionResult_Valid) { 802 DEBUG_EXPR(GENERATED_COMP, MedPrio, next_state); 803 DEBUG_NEWLINE(GENERATED_COMP, MedPrio); 804 s_profiler.countTransition(state, event); 805 if (Debug::getProtocolTrace()) { 806 g_system_ptr->getProfiler()->profileTransition("${ident}", 807 m_version, addr, 808 ${ident}_State_to_string(state), 809 ${ident}_Event_to_string(event), 810 ${ident}_State_to_string(next_state), 811 GET_TRANSITION_COMMENT()); 812 } 813 CLEAR_TRANSITION_COMMENT(); 814 ${ident}_setState(addr, next_state); 815 816 } else if (result == TransitionResult_ResourceStall) { 817 if (Debug::getProtocolTrace()) { 818 g_system_ptr->getProfiler()->profileTransition("${ident}", 819 m_version, addr, 820 ${ident}_State_to_string(state), 821 ${ident}_Event_to_string(event), 822 ${ident}_State_to_string(next_state), 823 "Resource Stall"); 824 } 825 } else if (result == TransitionResult_ProtocolStall) { 826 DEBUG_MSG(GENERATED_COMP, HighPrio, "stalling"); 827 DEBUG_NEWLINE(GENERATED_COMP, MedPrio); 828 if (Debug::getProtocolTrace()) { 829 g_system_ptr->getProfiler()->profileTransition("${ident}", 830 m_version, addr, 831 ${ident}_State_to_string(state), 832 ${ident}_Event_to_string(event), 833 ${ident}_State_to_string(next_state), 834 "Protocol Stall"); 835 } 836 } 837 838 return result; 839} 840 841TransitionResult 842${ident}_Controller::doTransitionWorker(${ident}_Event event, 843 ${ident}_State state, 844 ${ident}_State& next_state, 845 const Address& addr) 846{ 847 switch(HASH_FUN(state, event)) { 848''') 849 850 # This map will allow suppress generating duplicate code 851 cases = orderdict() 852 853 for trans in self.transitions: 854 case_string = "%s_State_%s, %s_Event_%s" % \ 855 (self.ident, trans.state.ident, self.ident, trans.event.ident) 856 857 case = self.symtab.codeFormatter() 858 # Only set next_state if it changes 859 if trans.state != trans.nextState: 860 ns_ident = trans.nextState.ident 861 case('next_state = ${ident}_State_${ns_ident};') 862 863 actions = trans.actions 864 865 # Check for resources 866 case_sorter = [] 867 res = trans.resources 868 for key,val in res.iteritems(): 869 if key.type.ident != "DNUCAStopTable": 870 val = ''' 871if (!%s.areNSlotsAvailable(%s)) 872 return TransitionResult_ResourceStall; 873''' % (key.code, val) 874 case_sorter.append(val) 875 876 877 # Emit the code sequences in a sorted order. This makes the 878 # output deterministic (without this the output order can vary 879 # since Map's keys() on a vector of pointers is not deterministic 880 for c in sorted(case_sorter): 881 case("$c") 882 883 # Figure out if we stall 884 stall = False 885 for action in actions: 886 if action.ident == "z_stall": 887 stall = True 888 break 889 890 if stall: 891 case('return TransitionResult_ProtocolStall;') 892 else: 893 for action in actions: 894 case('${{action.ident}}(addr);') 895 case('return TransitionResult_Valid;') 896 897 case = str(case) 898 899 # Look to see if this transition code is unique. 900 if case not in cases: 901 cases[case] = [] 902 903 cases[case].append(case_string) 904 905 # Walk through all of the unique code blocks and spit out the 906 # corresponding case statement elements 907 for case,transitions in cases.iteritems(): 908 # Iterative over all the multiple transitions that share 909 # the same code 910 for trans in transitions: 911 code(' case HASH_FUN($trans):') 912 code(' $case') 913 914 code(''' 915 default: 916 WARN_EXPR(m_version); 917 WARN_EXPR(g_eventQueue_ptr->getTime()); 918 WARN_EXPR(addr); 919 WARN_EXPR(event); 920 WARN_EXPR(state); 921 ERROR_MSG(\"Invalid transition\"); 922 } 923 return TransitionResult_Valid; 924} 925''') 926 code.write(path, "%s_Transitions.cc" % self.ident) 927 928 def printProfilerHH(self, path): 929 code = self.symtab.codeFormatter() 930 ident = self.ident 931 932 code(''' 933// Auto generated C++ code started by $__file__:$__line__ 934// ${ident}: ${{self.short}} 935 936#ifndef __${ident}_PROFILER_HH_ 937#define __${ident}_PROFILER_HH_ 938 939#include <iostream> 940 941#include "mem/ruby/common/Global.hh" 942#include "mem/protocol/${ident}_State.hh" 943#include "mem/protocol/${ident}_Event.hh" 944 945class ${ident}_Profiler 946{ 947 public: 948 ${ident}_Profiler(); 949 void setVersion(int version); 950 void countTransition(${ident}_State state, ${ident}_Event event); 951 void possibleTransition(${ident}_State state, ${ident}_Event event); 952 void dumpStats(std::ostream& out) const; 953 void clearStats(); 954 955 private: 956 int m_counters[${ident}_State_NUM][${ident}_Event_NUM]; 957 int m_event_counters[${ident}_Event_NUM]; 958 bool m_possible[${ident}_State_NUM][${ident}_Event_NUM]; 959 int m_version; 960}; 961 962#endif // __${ident}_PROFILER_HH__ 963''') 964 code.write(path, "%s_Profiler.hh" % self.ident) 965 966 def printProfilerCC(self, path): 967 code = self.symtab.codeFormatter() 968 ident = self.ident 969 970 code(''' 971// Auto generated C++ code started by $__file__:$__line__ 972// ${ident}: ${{self.short}} 973 974#include "mem/protocol/${ident}_Profiler.hh" 975 976${ident}_Profiler::${ident}_Profiler() 977{ 978 for (int state = 0; state < ${ident}_State_NUM; state++) { 979 for (int event = 0; event < ${ident}_Event_NUM; event++) { 980 m_possible[state][event] = false; 981 m_counters[state][event] = 0; 982 } 983 } 984 for (int event = 0; event < ${ident}_Event_NUM; event++) { 985 m_event_counters[event] = 0; 986 } 987} 988 989void 990${ident}_Profiler::setVersion(int version) 991{ 992 m_version = version; 993} 994 995void 996${ident}_Profiler::clearStats() 997{ 998 for (int state = 0; state < ${ident}_State_NUM; state++) { 999 for (int event = 0; event < ${ident}_Event_NUM; event++) { 1000 m_counters[state][event] = 0; 1001 } 1002 } 1003 1004 for (int event = 0; event < ${ident}_Event_NUM; event++) { 1005 m_event_counters[event] = 0; 1006 } 1007} 1008void 1009${ident}_Profiler::countTransition(${ident}_State state, ${ident}_Event event) 1010{ 1011 assert(m_possible[state][event]); 1012 m_counters[state][event]++; 1013 m_event_counters[event]++; 1014} 1015void 1016${ident}_Profiler::possibleTransition(${ident}_State state, 1017 ${ident}_Event event) 1018{ 1019 m_possible[state][event] = true; 1020} 1021 1022void 1023${ident}_Profiler::dumpStats(std::ostream& out) const 1024{ 1025 using namespace std; 1026 1027 out << " --- ${ident} " << m_version << " ---" << endl; 1028 out << " - Event Counts -" << endl; 1029 for (int event = 0; event < ${ident}_Event_NUM; event++) { 1030 int count = m_event_counters[event]; 1031 out << (${ident}_Event) event << " " << count << endl; 1032 } 1033 out << endl; 1034 out << " - Transitions -" << endl; 1035 for (int state = 0; state < ${ident}_State_NUM; state++) { 1036 for (int event = 0; event < ${ident}_Event_NUM; event++) { 1037 if (m_possible[state][event]) { 1038 int count = m_counters[state][event]; 1039 out << (${ident}_State) state << " " 1040 << (${ident}_Event) event << " " << count; 1041 if (count == 0) { 1042 out << " <-- "; 1043 } 1044 out << endl; 1045 } 1046 } 1047 out << endl; 1048 } 1049} 1050''') 1051 code.write(path, "%s_Profiler.cc" % self.ident) 1052 1053 # ************************** 1054 # ******* HTML Files ******* 1055 # ************************** 1056 def frameRef(self, click_href, click_target, over_href, over_num, text): 1057 code = self.symtab.codeFormatter(fix_newlines=False) 1058 code("""<A href=\"$click_href\" target=\"$click_target\" onmouseover=\" 1059 if (parent.frames[$over_num].location != parent.location + '$over_href') { 1060 parent.frames[$over_num].location='$over_href' 1061 }\"> 1062 ${{html.formatShorthand(text)}} 1063 </A>""") 1064 return str(code) 1065 1066 def writeHTMLFiles(self, path): 1067 # Create table with no row hilighted 1068 self.printHTMLTransitions(path, None) 1069 1070 # Generate transition tables 1071 for state in self.states.itervalues(): 1072 self.printHTMLTransitions(path, state) 1073 1074 # Generate action descriptions 1075 for action in self.actions.itervalues(): 1076 name = "%s_action_%s.html" % (self.ident, action.ident) 1077 code = html.createSymbol(action, "Action") 1078 code.write(path, name) 1079 1080 # Generate state descriptions 1081 for state in self.states.itervalues(): 1082 name = "%s_State_%s.html" % (self.ident, state.ident) 1083 code = html.createSymbol(state, "State") 1084 code.write(path, name) 1085 1086 # Generate event descriptions 1087 for event in self.events.itervalues(): 1088 name = "%s_Event_%s.html" % (self.ident, event.ident) 1089 code = html.createSymbol(event, "Event") 1090 code.write(path, name) 1091 1092 def printHTMLTransitions(self, path, active_state): 1093 code = self.symtab.codeFormatter() 1094 1095 code(''' 1096<HTML> 1097<BODY link="blue" vlink="blue"> 1098 1099<H1 align="center">${{html.formatShorthand(self.short)}}: 1100''') 1101 code.indent() 1102 for i,machine in enumerate(self.symtab.getAllType(StateMachine)): 1103 mid = machine.ident 1104 if i != 0: 1105 extra = " - " 1106 else: 1107 extra = "" 1108 if machine == self: 1109 code('$extra$mid') 1110 else: 1111 code('$extra<A target="Table" href="${mid}_table.html">$mid</A>') 1112 code.dedent() 1113 1114 code(""" 1115</H1> 1116 1117<TABLE border=1> 1118<TR> 1119 <TH> </TH> 1120""") 1121 1122 for event in self.events.itervalues(): 1123 href = "%s_Event_%s.html" % (self.ident, event.ident) 1124 ref = self.frameRef(href, "Status", href, "1", event.short) 1125 code('<TH bgcolor=white>$ref</TH>') 1126 1127 code('</TR>') 1128 # -- Body of table 1129 for state in self.states.itervalues(): 1130 # -- Each row 1131 if state == active_state: 1132 color = "yellow" 1133 else: 1134 color = "white" 1135 1136 click = "%s_table_%s.html" % (self.ident, state.ident) 1137 over = "%s_State_%s.html" % (self.ident, state.ident) 1138 text = html.formatShorthand(state.short) 1139 ref = self.frameRef(click, "Table", over, "1", state.short) 1140 code(''' 1141<TR> 1142 <TH bgcolor=$color>$ref</TH> 1143''') 1144 1145 # -- One column for each event 1146 for event in self.events.itervalues(): 1147 trans = self.table.get((state,event), None) 1148 if trans is None: 1149 # This is the no transition case 1150 if state == active_state: 1151 color = "#C0C000" 1152 else: 1153 color = "lightgrey" 1154 1155 code('<TD bgcolor=$color> </TD>') 1156 continue 1157 1158 next = trans.nextState 1159 stall_action = False 1160 1161 # -- Get the actions 1162 for action in trans.actions: 1163 if action.ident == "z_stall" or \ 1164 action.ident == "zz_recycleMandatoryQueue": 1165 stall_action = True 1166 1167 # -- Print out "actions/next-state" 1168 if stall_action: 1169 if state == active_state: 1170 color = "#C0C000" 1171 else: 1172 color = "lightgrey" 1173 1174 elif active_state and next.ident == active_state.ident: 1175 color = "aqua" 1176 elif state == active_state: 1177 color = "yellow" 1178 else: 1179 color = "white" 1180 1181 code('<TD bgcolor=$color>') 1182 for action in trans.actions: 1183 href = "%s_action_%s.html" % (self.ident, action.ident) 1184 ref = self.frameRef(href, "Status", href, "1", 1185 action.short) 1186 code(' $ref') 1187 if next != state: 1188 if trans.actions: 1189 code('/') 1190 click = "%s_table_%s.html" % (self.ident, next.ident) 1191 over = "%s_State_%s.html" % (self.ident, next.ident) 1192 ref = self.frameRef(click, "Table", over, "1", next.short) 1193 code("$ref") 1194 code("</TD>") 1195 1196 # -- Each row 1197 if state == active_state: 1198 color = "yellow" 1199 else: 1200 color = "white" 1201 1202 click = "%s_table_%s.html" % (self.ident, state.ident) 1203 over = "%s_State_%s.html" % (self.ident, state.ident) 1204 ref = self.frameRef(click, "Table", over, "1", state.short) 1205 code(''' 1206 <TH bgcolor=$color>$ref</TH> 1207</TR> 1208''') 1209 code(''' 1210<!- Column footer-> 1211<TR> 1212 <TH> </TH> 1213''') 1214 1215 for event in self.events.itervalues(): 1216 href = "%s_Event_%s.html" % (self.ident, event.ident) 1217 ref = self.frameRef(href, "Status", href, "1", event.short) 1218 code('<TH bgcolor=white>$ref</TH>') 1219 code(''' 1220</TR> 1221</TABLE> 1222</BODY></HTML> 1223''') 1224 1225 1226 if active_state: 1227 name = "%s_table_%s.html" % (self.ident, active_state.ident) 1228 else: 1229 name = "%s_table.html" % self.ident 1230 code.write(path, name) 1231 1232__all__ = [ "StateMachine" ] 1233