src/mem/slicc/symbols/StateMachine.py

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