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