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