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:
| 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:
|
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> </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" ]
| 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> </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" ]
|