from slicc.symbols.Symbol import Symbol
from slicc.symbols.Var import Var
import slicc.generate.html as html
+import re
-python_class_map = {"int": "Int",
+python_class_map = {
+ "int": "Int",
+ "uint32_t" : "UInt32",
"std::string": "String",
"bool": "Bool",
"CacheMemory": "RubyCache",
+ "WireBuffer": "RubyWireBuffer",
"Sequencer": "RubySequencer",
"DirectoryMemory": "RubyDirectoryMemory",
- "MemoryControl": "RubyMemoryControl",
- "DMASequencer": "DMASequencer"
- }
+ "MemoryControl": "MemoryControl",
+ "DMASequencer": "DMASequencer",
+ "Prefetcher":"Prefetcher",
+ "Cycles":"Cycles",
+ }
class StateMachine(Symbol):
def __init__(self, symtab, ident, location, pairs, config_parameters):
super(StateMachine, self).__init__(symtab, ident, location, pairs)
self.table = None
self.config_parameters = config_parameters
+ self.prefetchers = []
+
for param in config_parameters:
if param.pointer:
var = Var(symtab, param.name, location, param.type_ast.type,
var = Var(symtab, param.name, location, param.type_ast.type,
"m_%s" % param.name, {}, self)
self.symtab.registerSym(param.name, var)
+ if str(param.type_ast.type) == "Prefetcher":
+ self.prefetchers.append(var)
self.states = orderdict()
self.events = orderdict()
self.actions = orderdict()
+ self.request_types = orderdict()
self.transitions = []
self.in_ports = []
self.functions = []
self.objects = []
-
- self.message_buffer_names = []
+ self.TBEType = None
+ self.EntryType = None
def __repr__(self):
return "[StateMachine: %s]" % self.ident
self.actions[action.ident] = action
+ def addRequestType(self, request_type):
+ assert self.table is None
+ self.request_types[request_type.ident] = request_type
+
def addTransition(self, trans):
assert self.table is None
self.transitions.append(trans)
def addObject(self, obj):
self.objects.append(obj)
+ def addType(self, type):
+ type_ident = '%s' % type.c_ident
+
+ if type_ident == "%s_TBE" %self.ident:
+ if self.TBEType != None:
+ self.error("Multiple Transaction Buffer types in a " \
+ "single machine.");
+ self.TBEType = type
+
+ elif "interface" in type and "AbstractCacheEntry" == type["interface"]:
+ if self.EntryType != None:
+ self.error("Multiple AbstractCacheEntry types in a " \
+ "single machine.");
+ self.EntryType = type
+
# Needs to be called before accessing the table
def buildTable(self):
assert self.table is None
action.warning(error_msg)
self.table = table
- def writeCodeFiles(self, path):
+ def writeCodeFiles(self, path, includes):
self.printControllerPython(path)
self.printControllerHH(path)
- self.printControllerCC(path)
+ self.printControllerCC(path, includes)
self.printCSwitch(path)
- self.printCWakeup(path)
- self.printProfilerCC(path)
- self.printProfilerHH(path)
- self.printProfileDumperCC(path)
- self.printProfileDumperHH(path)
-
- for func in self.functions:
- func.writeCodeFiles(path)
+ self.printCWakeup(path, includes)
def printControllerPython(self, path):
code = self.symtab.codeFormatter()
class $py_ident(RubyController):
type = '$py_ident'
+ cxx_header = 'mem/protocol/${c_ident}.hh'
''')
code.indent()
for param in self.config_parameters:
ident = self.ident
c_ident = "%s_Controller" % self.ident
- self.message_buffer_names = []
-
code('''
/** \\file $c_ident.hh
*
#include <sstream>
#include <string>
-#include "params/$c_ident.hh"
-
-#include "mem/ruby/common/Global.hh"
-#include "mem/ruby/common/Consumer.hh"
-#include "mem/ruby/slicc_interface/AbstractController.hh"
#include "mem/protocol/TransitionResult.hh"
#include "mem/protocol/Types.hh"
-#include "mem/protocol/${ident}_Profiler.hh"
-#include "mem/protocol/${ident}_ProfileDumper.hh"
+#include "mem/ruby/common/Consumer.hh"
+#include "mem/ruby/common/Global.hh"
+#include "mem/ruby/slicc_interface/AbstractController.hh"
+#include "params/$c_ident.hh"
''')
seen_types = set()
+ has_peer = False
for var in self.objects:
if var.type.ident not in seen_types and not var.type.isPrimitive:
code('#include "mem/protocol/${{var.type.c_ident}}.hh"')
+ if "network" in var and "physical_network" in var:
+ has_peer = True
seen_types.add(var.type.ident)
# for adding information to the protocol debug trace
class $c_ident : public AbstractController
{
-// the coherence checker needs to call isBlockExclusive() and isBlockShared()
-// making the Chip a friend class is an easy way to do this for now
-
-public:
+ public:
typedef ${c_ident}Params Params;
$c_ident(const Params *p);
static int getNumControllers();
void init();
MessageBuffer* getMandatoryQueue() const;
- const int & getVersion() const;
const std::string toString() const;
- const std::string getName() const;
- const MachineType getMachineType() const;
- void stallBuffer(MessageBuffer* buf, Address addr);
- void wakeUpBuffers(Address addr);
- void initNetworkPtr(Network* net_ptr) { m_net_ptr = net_ptr; }
+
void print(std::ostream& out) const;
- void printConfig(std::ostream& out) const;
void wakeup();
- void printStats(std::ostream& out) const;
- void clearStats();
- void blockOnQueue(Address addr, MessageBuffer* port);
- void unblock(Address addr);
+ void resetStats();
+ void regStats();
+ void collateStats();
+
+ void recordCacheTrace(int cntrl, CacheRecorder* tr);
+ Sequencer* getSequencer() const;
+
+ bool functionalReadBuffers(PacketPtr&);
+ uint32_t functionalWriteBuffers(PacketPtr&);
+
+ void countTransition(${ident}_State state, ${ident}_Event event);
+ void possibleTransition(${ident}_State state, ${ident}_Event event);
+ uint64 getEventCount(${ident}_Event event);
+ bool isPossible(${ident}_State state, ${ident}_Event event);
+ uint64 getTransitionCount(${ident}_State state, ${ident}_Event event);
private:
''')
code('${{param.type_ast.type}} m_${{param.ident}};')
code('''
-int m_number_of_TBEs;
-
TransitionResult doTransition(${ident}_Event event,
- ${ident}_State state,
- const Address& addr);
+''')
+
+ if self.EntryType != None:
+ code('''
+ ${{self.EntryType.c_ident}}* m_cache_entry_ptr,
+''')
+ if self.TBEType != None:
+ code('''
+ ${{self.TBEType.c_ident}}* m_tbe_ptr,
+''')
+
+ code('''
+ const Address addr);
TransitionResult doTransitionWorker(${ident}_Event event,
${ident}_State state,
${ident}_State& next_state,
+''')
+
+ if self.TBEType != None:
+ code('''
+ ${{self.TBEType.c_ident}}*& m_tbe_ptr,
+''')
+ if self.EntryType != None:
+ code('''
+ ${{self.EntryType.c_ident}}*& m_cache_entry_ptr,
+''')
+
+ code('''
const Address& addr);
-std::string m_name;
-int m_transitions_per_cycle;
-int m_buffer_size;
-int m_recycle_latency;
-std::map<std::string, std::string> m_cfg;
-NodeID m_version;
-Network* m_net_ptr;
-MachineID m_machineID;
-bool m_is_blocking;
-std::map<Address, MessageBuffer*> m_block_map;
-typedef std::vector<MessageBuffer*> MsgVecType;
-typedef m5::hash_map< Address, MsgVecType* > WaitingBufType;
-WaitingBufType m_waiting_buffers;
-int m_max_in_port_rank;
-int m_cur_in_port_rank;
-static ${ident}_ProfileDumper s_profileDumper;
-${ident}_Profiler m_profiler;
+int m_counters[${ident}_State_NUM][${ident}_Event_NUM];
+int m_event_counters[${ident}_Event_NUM];
+bool m_possible[${ident}_State_NUM][${ident}_Event_NUM];
+
+static std::vector<Stats::Vector *> eventVec;
+static std::vector<std::vector<Stats::Vector *> > transVec;
static int m_num_controllers;
// Internal functions
if proto:
code('$proto')
+ if has_peer:
+ code('void getQueuesFromPeer(AbstractController *);')
+ if self.EntryType != None:
+ code('''
+
+// Set and Reset for cache_entry variable
+void set_cache_entry(${{self.EntryType.c_ident}}*& m_cache_entry_ptr, AbstractCacheEntry* m_new_cache_entry);
+void unset_cache_entry(${{self.EntryType.c_ident}}*& m_cache_entry_ptr);
+''')
+
+ if self.TBEType != None:
+ code('''
+
+// Set and Reset for tbe variable
+void set_tbe(${{self.TBEType.c_ident}}*& m_tbe_ptr, ${ident}_TBE* m_new_tbe);
+void unset_tbe(${{self.TBEType.c_ident}}*& m_tbe_ptr);
+''')
+
+ # Prototype the actions that the controller can take
code('''
// Actions
''')
- for action in self.actions.itervalues():
- code('/** \\brief ${{action.desc}} */')
- code('void ${{action.ident}}(const Address& addr);')
+ if self.TBEType != None and self.EntryType != None:
+ for action in self.actions.itervalues():
+ code('/** \\brief ${{action.desc}} */')
+ code('void ${{action.ident}}(${{self.TBEType.c_ident}}*& '
+ 'm_tbe_ptr, ${{self.EntryType.c_ident}}*& '
+ 'm_cache_entry_ptr, const Address& addr);')
+ elif self.TBEType != None:
+ for action in self.actions.itervalues():
+ code('/** \\brief ${{action.desc}} */')
+ code('void ${{action.ident}}(${{self.TBEType.c_ident}}*& '
+ 'm_tbe_ptr, const Address& addr);')
+ elif self.EntryType != None:
+ for action in self.actions.itervalues():
+ code('/** \\brief ${{action.desc}} */')
+ code('void ${{action.ident}}(${{self.EntryType.c_ident}}*& '
+ 'm_cache_entry_ptr, const Address& addr);')
+ else:
+ for action in self.actions.itervalues():
+ code('/** \\brief ${{action.desc}} */')
+ code('void ${{action.ident}}(const Address& addr);')
# the controller internal variables
code('''
// Objects
''')
for var in self.objects:
- th = var.get("template_hack", "")
+ th = var.get("template", "")
code('${{var.type.c_ident}}$th* m_${{var.c_ident}}_ptr;')
- if var.type.ident == "MessageBuffer":
- self.message_buffer_names.append("m_%s_ptr" % var.c_ident)
-
code.dedent()
code('};')
code('#endif // __${ident}_CONTROLLER_H__')
code.write(path, '%s.hh' % c_ident)
- def printControllerCC(self, path):
+ def printControllerCC(self, path, includes):
'''Output the actions for performing the actions'''
code = self.symtab.codeFormatter()
ident = self.ident
c_ident = "%s_Controller" % self.ident
+ has_peer = False
code('''
/** \\file $c_ident.cc
* Created by slicc definition of Module "${{self.short}}"
*/
+#include <sys/types.h>
+#include <unistd.h>
+
#include <cassert>
#include <sstream>
#include <string>
+#include "base/compiler.hh"
#include "base/cprintf.hh"
+#include "debug/RubyGenerated.hh"
+#include "debug/RubySlicc.hh"
#include "mem/protocol/${ident}_Controller.hh"
-#include "mem/protocol/${ident}_State.hh"
#include "mem/protocol/${ident}_Event.hh"
+#include "mem/protocol/${ident}_State.hh"
#include "mem/protocol/Types.hh"
#include "mem/ruby/common/Global.hh"
-#include "mem/ruby/slicc_interface/RubySlicc_includes.hh"
#include "mem/ruby/system/System.hh"
+''')
+ for include_path in includes:
+ code('#include "${{include_path}}"')
+
+ code('''
using namespace std;
''')
code('#include "mem/protocol/${{var.type.c_ident}}.hh"')
seen_types.add(var.type.ident)
+ num_in_ports = len(self.in_ports)
+
code('''
$c_ident *
${c_ident}Params::create()
}
int $c_ident::m_num_controllers = 0;
-${ident}_ProfileDumper $c_ident::s_profileDumper;
+std::vector<Stats::Vector *> $c_ident::eventVec;
+std::vector<std::vector<Stats::Vector *> > $c_ident::transVec;
// for adding information to the protocol debug trace
stringstream ${ident}_transitionComment;
+
+#ifndef NDEBUG
#define APPEND_TRANSITION_COMMENT(str) (${ident}_transitionComment << str)
+#else
+#define APPEND_TRANSITION_COMMENT(str) do {} while (0)
+#endif
/** \\brief constructor */
$c_ident::$c_ident(const Params *p)
: AbstractController(p)
{
- m_version = p->version;
- m_transitions_per_cycle = p->transitions_per_cycle;
- m_buffer_size = p->buffer_size;
- m_recycle_latency = p->recycle_latency;
- m_number_of_TBEs = p->number_of_TBEs;
- m_is_blocking = false;
+ m_machineID.type = MachineType_${ident};
+ m_machineID.num = m_version;
+ m_num_controllers++;
+
+ m_in_ports = $num_in_ports;
''')
- #
- # max_port_rank is used to size vectors and thus should be one plus the
- # largest port rank
- #
- max_port_rank = self.in_ports[0].pairs["max_port_rank"] + 1
- code(' m_max_in_port_rank = $max_port_rank;')
code.indent()
#
# After initializing the universal machine parameters, initialize the
- # this machines config parameters. Also detemine if these configuration
- # params include a sequencer. This information will be used later for
- # contecting the sequencer back to the L1 cache controller.
+ # this machines config parameters. Also if these configuration params
+ # include a sequencer, connect the it to the controller.
#
- contains_sequencer = False
for param in self.config_parameters:
- if param.name == "sequencer" or param.name == "dma_sequencer":
- contains_sequencer = True
if param.pointer:
code('m_${{param.name}}_ptr = p->${{param.name}};')
else:
code('m_${{param.name}} = p->${{param.name}};')
-
- #
- # For the l1 cache controller, add the special atomic support which
- # includes passing the sequencer a pointer to the controller.
- #
- if self.ident == "L1Cache":
- if not contains_sequencer:
- self.error("The L1Cache controller must include the sequencer " \
- "configuration parameter")
-
- code('''
-m_sequencer_ptr->setController(this);
-''')
- #
- # For the DMA controller, pass the sequencer a pointer to the
- # controller.
- #
- if self.ident == "DMA":
- if not contains_sequencer:
- self.error("The DMA controller must include the sequencer " \
- "configuration parameter")
-
- code('''
-m_dma_sequencer_ptr->setController(this);
-''')
+ if re.compile("sequencer").search(param.name):
+ code('m_${{param.name}}_ptr->setController(this);')
- code('m_num_controllers++;')
for var in self.objects:
if var.ident.find("mandatoryQueue") >= 0:
- code('m_${{var.c_ident}}_ptr = new ${{var.type.c_ident}}();')
+ code('''
+m_${{var.c_ident}}_ptr = new ${{var.type.c_ident}}();
+m_${{var.c_ident}}_ptr->setReceiver(this);
+''')
+ else:
+ if "network" in var and "physical_network" in var and \
+ var["network"] == "To":
+ has_peer = True
+ code('''
+m_${{var.c_ident}}_ptr = new ${{var.type.c_ident}}();
+peerQueueMap[${{var["physical_network"]}}] = m_${{var.c_ident}}_ptr;
+m_${{var.c_ident}}_ptr->setSender(this);
+''')
+
+ code('''
+if (p->peer != NULL)
+ connectWithPeer(p->peer);
+for (int state = 0; state < ${ident}_State_NUM; state++) {
+ for (int event = 0; event < ${ident}_Event_NUM; event++) {
+ m_possible[state][event] = false;
+ m_counters[state][event] = 0;
+ }
+}
+for (int event = 0; event < ${ident}_Event_NUM; event++) {
+ m_event_counters[event] = 0;
+}
+''')
code.dedent()
code('''
}
void
$c_ident::init()
{
- MachineType machine_type;
- int base;
-
- m_machineID.type = MachineType_${ident};
- m_machineID.num = m_version;
+ MachineType machine_type = string_to_MachineType("${{var.machine.ident}}");
+ int base M5_VAR_USED = MachineType_base_number(machine_type);
// initialize objects
- m_profiler.setVersion(m_version);
- s_profileDumper.registerProfiler(&m_profiler);
''')
code('(*$vid) = ${{var["default"]}};')
else:
# Normal Object
- # added by SS
- if "factory" in var:
- code('$vid = ${{var["factory"]}};')
- elif var.ident.find("mandatoryQueue") < 0:
- th = var.get("template_hack", "")
+ if var.ident.find("mandatoryQueue") < 0:
+ th = var.get("template", "")
expr = "%s = new %s%s" % (vid, vtype.c_ident, th)
-
args = ""
if "non_obj" not in vtype and not vtype.isEnumeration:
- if expr.find("TBETable") >= 0:
- args = "m_number_of_TBEs"
- else:
- args = var.get("constructor_hack", "")
-
+ args = var.get("constructor", "")
code('$expr($args);')
code('assert($vid != NULL);')
code('*$vid = ${{vtype["default"]}}; // $comment')
# Set ordering
- if "ordered" in var and "trigger_queue" not in var:
+ if "ordered" in var:
# A buffer
code('$vid->setOrdering(${{var["ordered"]}});')
code('$vid->setRandomization(${{var["random"]}});')
# Set Priority
- if vtype.isBuffer and \
- "rank" in var and "trigger_queue" not in var:
+ if vtype.isBuffer and "rank" in var:
code('$vid->setPriority(${{var["rank"]}});')
+ # Set sender and receiver for trigger queue
+ if var.ident.find("triggerQueue") >= 0:
+ code('$vid->setSender(this);')
+ code('$vid->setReceiver(this);')
+ elif vtype.c_ident == "TimerTable":
+ code('$vid->setClockObj(this);')
+ elif var.ident.find("optionalQueue") >= 0:
+ code('$vid->setSender(this);')
+ code('$vid->setReceiver(this);')
+
else:
# Network port object
network = var["network"]
ordered = var["ordered"]
- vnet = var["virtual_network"]
- assert var.machine is not None
- code('''
-machine_type = string_to_MachineType("${{var.machine.ident}}");
-base = MachineType_base_number(machine_type);
-$vid = m_net_ptr->get${network}NetQueue(m_version + base, $ordered, $vnet);
+ if "virtual_network" in var:
+ vnet = var["virtual_network"]
+ vnet_type = var["vnet_type"]
+
+ assert var.machine is not None
+ code('''
+$vid = m_net_ptr->get${network}NetQueue(m_version + base, $ordered, $vnet, "$vnet_type");
+assert($vid != NULL);
''')
- code('assert($vid != NULL);')
+ # Set the end
+ if network == "To":
+ code('$vid->setSender(this);')
+ else:
+ code('$vid->setReceiver(this);')
# Set ordering
if "ordered" in var:
# Set randomization
if "random" in var:
# A buffer
- code('$vid->setRandomization(${{var["random"]}})')
+ code('$vid->setRandomization(${{var["random"]}});')
# Set Priority
if "rank" in var:
if vtype.isBuffer:
if "recycle_latency" in var:
- code('$vid->setRecycleLatency(${{var["recycle_latency"]}});')
+ code('$vid->setRecycleLatency( ' \
+ 'Cycles(${{var["recycle_latency"]}}));')
else:
code('$vid->setRecycleLatency(m_recycle_latency);')
-
- # Set the queue consumers
+ # Set the prefetchers
code()
- for port in self.in_ports:
- code('${{port.code}}.setConsumer(this);')
+ for prefetcher in self.prefetchers:
+ code('${{prefetcher.code}}.setController(this);')
- # Set the queue descriptions
code()
for port in self.in_ports:
+ # Set the queue consumers
+ code('${{port.code}}.setConsumer(this);')
+ # Set the queue descriptions
code('${{port.code}}.setDescription("[Version " + to_string(m_version) + ", $ident, $port]");')
# Initialize the transition profiling
if not stall:
state = "%s_State_%s" % (self.ident, trans.state.ident)
event = "%s_Event_%s" % (self.ident, trans.event.ident)
- code('m_profiler.possibleTransition($state, $event);')
+ code('possibleTransition($state, $event);')
code.dedent()
- code('}')
+ code('''
+ AbstractController::init();
+ resetStats();
+}
+''')
- has_mandatory_q = False
+ mq_ident = "NULL"
for port in self.in_ports:
if port.code.find("mandatoryQueue_ptr") >= 0:
- has_mandatory_q = True
+ mq_ident = "m_%s_mandatoryQueue_ptr" % self.ident
- if has_mandatory_q:
- mq_ident = "m_%s_mandatoryQueue_ptr" % self.ident
- else:
- mq_ident = "NULL"
+ seq_ident = "NULL"
+ for param in self.config_parameters:
+ if param.name == "sequencer":
+ assert(param.pointer)
+ seq_ident = "m_%s_ptr" % param.name
code('''
+
+void
+$c_ident::regStats()
+{
+ AbstractController::regStats();
+
+ if (m_version == 0) {
+ for (${ident}_Event event = ${ident}_Event_FIRST;
+ event < ${ident}_Event_NUM; ++event) {
+ Stats::Vector *t = new Stats::Vector();
+ t->init(m_num_controllers);
+ t->name(g_system_ptr->name() + ".${c_ident}." +
+ ${ident}_Event_to_string(event));
+ t->flags(Stats::pdf | Stats::total | Stats::oneline |
+ Stats::nozero);
+
+ eventVec.push_back(t);
+ }
+
+ for (${ident}_State state = ${ident}_State_FIRST;
+ state < ${ident}_State_NUM; ++state) {
+
+ transVec.push_back(std::vector<Stats::Vector *>());
+
+ for (${ident}_Event event = ${ident}_Event_FIRST;
+ event < ${ident}_Event_NUM; ++event) {
+
+ Stats::Vector *t = new Stats::Vector();
+ t->init(m_num_controllers);
+ t->name(g_system_ptr->name() + ".${c_ident}." +
+ ${ident}_State_to_string(state) +
+ "." + ${ident}_Event_to_string(event));
+
+ t->flags(Stats::pdf | Stats::total | Stats::oneline |
+ Stats::nozero);
+ transVec[state].push_back(t);
+ }
+ }
+ }
+}
+
+void
+$c_ident::collateStats()
+{
+ for (${ident}_Event event = ${ident}_Event_FIRST;
+ event < ${ident}_Event_NUM; ++event) {
+ for (unsigned int i = 0; i < m_num_controllers; ++i) {
+ std::map<uint32_t, AbstractController *>::iterator it =
+ g_abs_controls[MachineType_${ident}].find(i);
+ assert(it != g_abs_controls[MachineType_${ident}].end());
+ (*eventVec[event])[i] =
+ (($c_ident *)(*it).second)->getEventCount(event);
+ }
+ }
+
+ for (${ident}_State state = ${ident}_State_FIRST;
+ state < ${ident}_State_NUM; ++state) {
+
+ for (${ident}_Event event = ${ident}_Event_FIRST;
+ event < ${ident}_Event_NUM; ++event) {
+
+ for (unsigned int i = 0; i < m_num_controllers; ++i) {
+ std::map<uint32_t, AbstractController *>::iterator it =
+ g_abs_controls[MachineType_${ident}].find(i);
+ assert(it != g_abs_controls[MachineType_${ident}].end());
+ (*transVec[state][event])[i] =
+ (($c_ident *)(*it).second)->getTransitionCount(state, event);
+ }
+ }
+ }
+}
+
+void
+$c_ident::countTransition(${ident}_State state, ${ident}_Event event)
+{
+ assert(m_possible[state][event]);
+ m_counters[state][event]++;
+ m_event_counters[event]++;
+}
+void
+$c_ident::possibleTransition(${ident}_State state,
+ ${ident}_Event event)
+{
+ m_possible[state][event] = true;
+}
+
+uint64
+$c_ident::getEventCount(${ident}_Event event)
+{
+ return m_event_counters[event];
+}
+
+bool
+$c_ident::isPossible(${ident}_State state, ${ident}_Event event)
+{
+ return m_possible[state][event];
+}
+
+uint64
+$c_ident::getTransitionCount(${ident}_State state,
+ ${ident}_Event event)
+{
+ return m_counters[state][event];
+}
+
int
$c_ident::getNumControllers()
{
return $mq_ident;
}
-const int &
-$c_ident::getVersion() const
+Sequencer*
+$c_ident::getSequencer() const
{
- return m_version;
+ return $seq_ident;
}
const string
return "$c_ident";
}
-const string
-$c_ident::getName() const
-{
- return m_name;
-}
-
-const MachineType
-$c_ident::getMachineType() const
-{
- return MachineType_${ident};
-}
-
void
-$c_ident::stallBuffer(MessageBuffer* buf, Address addr)
+$c_ident::print(ostream& out) const
{
- if (m_waiting_buffers.count(addr) == 0) {
- MsgVecType* msgVec = new MsgVecType;
- msgVec->resize(m_max_in_port_rank, NULL);
- m_waiting_buffers[addr] = msgVec;
- }
- (*(m_waiting_buffers[addr]))[m_cur_in_port_rank] = buf;
+ out << "[$c_ident " << m_version << "]";
}
-void
-$c_ident::wakeUpBuffers(Address addr)
+void $c_ident::resetStats()
{
- //
- // Wake up all possible lower rank (i.e. lower priority) buffers that could
- // be waiting on this message.
- //
- for (int in_port_rank = m_cur_in_port_rank - 1;
- in_port_rank >= 0;
- in_port_rank--) {
- if ((*(m_waiting_buffers[addr]))[in_port_rank] != NULL) {
- (*(m_waiting_buffers[addr]))[in_port_rank]->reanalyzeMessages(addr);
+ for (int state = 0; state < ${ident}_State_NUM; state++) {
+ for (int event = 0; event < ${ident}_Event_NUM; event++) {
+ m_counters[state][event] = 0;
}
}
- delete m_waiting_buffers[addr];
- m_waiting_buffers.erase(addr);
+
+ for (int event = 0; event < ${ident}_Event_NUM; event++) {
+ m_event_counters[event] = 0;
+ }
+
+ AbstractController::resetStats();
}
+''')
+
+ if self.EntryType != None:
+ code('''
+// Set and Reset for cache_entry variable
void
-$c_ident::blockOnQueue(Address addr, MessageBuffer* port)
+$c_ident::set_cache_entry(${{self.EntryType.c_ident}}*& m_cache_entry_ptr, AbstractCacheEntry* m_new_cache_entry)
{
- m_is_blocking = true;
- m_block_map[addr] = port;
+ m_cache_entry_ptr = (${{self.EntryType.c_ident}}*)m_new_cache_entry;
}
void
-$c_ident::unblock(Address addr)
+$c_ident::unset_cache_entry(${{self.EntryType.c_ident}}*& m_cache_entry_ptr)
{
- m_block_map.erase(addr);
- if (m_block_map.size() == 0) {
- m_is_blocking = false;
- }
+ m_cache_entry_ptr = 0;
}
+''')
+
+ if self.TBEType != None:
+ code('''
+// Set and Reset for tbe variable
void
-$c_ident::print(ostream& out) const
+$c_ident::set_tbe(${{self.TBEType.c_ident}}*& m_tbe_ptr, ${{self.TBEType.c_ident}}* m_new_tbe)
{
- out << "[$c_ident " << m_version << "]";
+ m_tbe_ptr = m_new_tbe;
}
void
-$c_ident::printConfig(ostream& out) const
+$c_ident::unset_tbe(${{self.TBEType.c_ident}}*& m_tbe_ptr)
{
- out << "$c_ident config: " << m_name << endl;
- out << " version: " << m_version << endl;
- map<string, string>::const_iterator it;
- for (it = m_cfg.begin(); it != m_cfg.end(); it++)
- out << " " << it->first << ": " << it->second << endl;
+ m_tbe_ptr = NULL;
}
+''')
+
+ code('''
void
-$c_ident::printStats(ostream& out) const
+$c_ident::recordCacheTrace(int cntrl, CacheRecorder* tr)
{
''')
#
- # Cache and Memory Controllers have specific profilers associated with
- # them. Print out these stats before dumping state transition stats.
+ # Record cache contents for all associated caches.
#
+ code.indent()
for param in self.config_parameters:
- if param.type_ast.type.ident == "CacheMemory" or \
- param.type_ast.type.ident == "DirectoryMemory" or \
- param.type_ast.type.ident == "MemoryControl":
+ if param.type_ast.type.ident == "CacheMemory":
assert(param.pointer)
- code(' m_${{param.ident}}_ptr->printStats(out);')
+ code('m_${{param.ident}}_ptr->recordCacheContents(cntrl, tr);')
+ code.dedent()
code('''
- if (m_version == 0) {
- s_profileDumper.dumpStats(out);
- }
}
-void $c_ident::clearStats() {
+// Actions
''')
- #
- # Cache and Memory Controllers have specific profilers associated with
- # them. These stats must be cleared too.
- #
- for param in self.config_parameters:
- if param.type_ast.type.ident == "CacheMemory" or \
- param.type_ast.type.ident == "MemoryControl":
- assert(param.pointer)
- code(' m_${{param.ident}}_ptr->clearStats();')
+ if self.TBEType != None and self.EntryType != None:
+ for action in self.actions.itervalues():
+ if "c_code" not in action:
+ continue
- code('''
- m_profiler.clearStats();
+ code('''
+/** \\brief ${{action.desc}} */
+void
+$c_ident::${{action.ident}}(${{self.TBEType.c_ident}}*& m_tbe_ptr, ${{self.EntryType.c_ident}}*& m_cache_entry_ptr, const Address& addr)
+{
+ DPRINTF(RubyGenerated, "executing ${{action.ident}}\\n");
+ ${{action["c_code"]}}
}
-// Actions
''')
+ elif self.TBEType != None:
+ for action in self.actions.itervalues():
+ if "c_code" not in action:
+ continue
- for action in self.actions.itervalues():
- if "c_code" not in action:
- continue
+ code('''
+/** \\brief ${{action.desc}} */
+void
+$c_ident::${{action.ident}}(${{self.TBEType.c_ident}}*& m_tbe_ptr, const Address& addr)
+{
+ DPRINTF(RubyGenerated, "executing ${{action.ident}}\\n");
+ ${{action["c_code"]}}
+}
- code('''
+''')
+ elif self.EntryType != None:
+ for action in self.actions.itervalues():
+ if "c_code" not in action:
+ continue
+
+ code('''
+/** \\brief ${{action.desc}} */
+void
+$c_ident::${{action.ident}}(${{self.EntryType.c_ident}}*& m_cache_entry_ptr, const Address& addr)
+{
+ DPRINTF(RubyGenerated, "executing ${{action.ident}}\\n");
+ ${{action["c_code"]}}
+}
+
+''')
+ else:
+ for action in self.actions.itervalues():
+ if "c_code" not in action:
+ continue
+
+ code('''
/** \\brief ${{action.desc}} */
void
$c_ident::${{action.ident}}(const Address& addr)
{
- DPRINTF(RubyGenerated, "executing\\n");
+ DPRINTF(RubyGenerated, "executing ${{action.ident}}\\n");
${{action["c_code"]}}
}
''')
+ for func in self.functions:
+ code(func.generateCode())
+
+ # Function for functional reads from messages buffered in the controller
+ code('''
+bool
+$c_ident::functionalReadBuffers(PacketPtr& pkt)
+{
+''')
+ for var in self.objects:
+ vtype = var.type
+ if vtype.isBuffer:
+ vid = "m_%s_ptr" % var.c_ident
+ code('if ($vid->functionalRead(pkt)) { return true; }')
+ code('''
+ return false;
+}
+''')
+
+ # Function for functional writes to messages buffered in the controller
+ code('''
+uint32_t
+$c_ident::functionalWriteBuffers(PacketPtr& pkt)
+{
+ uint32_t num_functional_writes = 0;
+''')
+ for var in self.objects:
+ vtype = var.type
+ if vtype.isBuffer:
+ vid = "m_%s_ptr" % var.c_ident
+ code('num_functional_writes += $vid->functionalWrite(pkt);')
+ code('''
+ return num_functional_writes;
+}
+''')
+
+ # Check if this controller has a peer, if yes then write the
+ # function for connecting to the peer.
+ if has_peer:
+ code('''
+
+void
+$c_ident::getQueuesFromPeer(AbstractController *peer)
+{
+''')
+ for var in self.objects:
+ if "network" in var and "physical_network" in var and \
+ var["network"] == "From":
+ code('''
+m_${{var.c_ident}}_ptr = peer->getPeerQueue(${{var["physical_network"]}});
+assert(m_${{var.c_ident}}_ptr != NULL);
+m_${{var.c_ident}}_ptr->setReceiver(this);
+
+''')
+ code('}')
+
code.write(path, "%s.cc" % c_ident)
- def printCWakeup(self, path):
+ def printCWakeup(self, path, includes):
'''Output the wakeup loop for the events'''
code = self.symtab.codeFormatter()
ident = self.ident
+ outputRequest_types = True
+ if len(self.request_types) == 0:
+ outputRequest_types = False
+
code('''
// Auto generated C++ code started by $__file__:$__line__
// ${ident}: ${{self.short}}
+#include <sys/types.h>
+#include <unistd.h>
+
#include <cassert>
#include "base/misc.hh"
-#include "mem/ruby/common/Global.hh"
-#include "mem/ruby/slicc_interface/RubySlicc_includes.hh"
+#include "debug/RubySlicc.hh"
#include "mem/protocol/${ident}_Controller.hh"
-#include "mem/protocol/${ident}_State.hh"
#include "mem/protocol/${ident}_Event.hh"
+#include "mem/protocol/${ident}_State.hh"
+''')
+
+ if outputRequest_types:
+ code('''#include "mem/protocol/${ident}_RequestType.hh"''')
+
+ code('''
#include "mem/protocol/Types.hh"
+#include "mem/ruby/common/Global.hh"
#include "mem/ruby/system/System.hh"
+''')
+
+
+ for include_path in includes:
+ code('#include "${{include_path}}"')
+
+ code('''
using namespace std;
void
${ident}_Controller::wakeup()
{
- // DEBUG_EXPR(GENERATED_COMP, MedPrio, *this);
- // DEBUG_EXPR(GENERATED_COMP, MedPrio, g_eventQueue_ptr->getTime());
-
int counter = 0;
while (true) {
// Some cases will put us into an infinite loop without this limit
assert(counter <= m_transitions_per_cycle);
if (counter == m_transitions_per_cycle) {
// Count how often we are fully utilized
- g_system_ptr->getProfiler()->controllerBusy(m_machineID);
+ m_fully_busy_cycles++;
// Wakeup in another cycle and try again
- g_eventQueue_ptr->scheduleEvent(this, 1);
+ scheduleEvent(Cycles(1));
break;
}
''')
code.indent()
code('// ${ident}InPort $port')
if port.pairs.has_key("rank"):
- code('m_cur_in_port_rank = ${{port.pairs["rank"]}};')
+ code('m_cur_in_port = ${{port.pairs["rank"]}};')
else:
- code('m_cur_in_port_rank = 0;')
+ code('m_cur_in_port = 0;')
code('${{port["c_code_in_port"]}}')
code.dedent()
code('''
break; // If we got this far, we have nothing left todo
}
- // g_eventQueue_ptr->scheduleEvent(this, 1);
}
''')
#include "base/misc.hh"
#include "base/trace.hh"
-#include "mem/ruby/common/Global.hh"
+#include "debug/ProtocolTrace.hh"
+#include "debug/RubyGenerated.hh"
#include "mem/protocol/${ident}_Controller.hh"
-#include "mem/protocol/${ident}_State.hh"
#include "mem/protocol/${ident}_Event.hh"
+#include "mem/protocol/${ident}_State.hh"
#include "mem/protocol/Types.hh"
+#include "mem/ruby/common/Global.hh"
#include "mem/ruby/system/System.hh"
#define HASH_FUN(state, event) ((int(state)*${ident}_Event_NUM)+int(event))
TransitionResult
${ident}_Controller::doTransition(${ident}_Event event,
- ${ident}_State state,
- const Address &addr)
+''')
+ if self.EntryType != None:
+ code('''
+ ${{self.EntryType.c_ident}}* m_cache_entry_ptr,
+''')
+ if self.TBEType != None:
+ code('''
+ ${{self.TBEType.c_ident}}* m_tbe_ptr,
+''')
+ code('''
+ const Address addr)
{
+''')
+ if self.TBEType != None and self.EntryType != None:
+ code('${ident}_State state = getState(m_tbe_ptr, m_cache_entry_ptr, addr);')
+ elif self.TBEType != None:
+ code('${ident}_State state = getState(m_tbe_ptr, addr);')
+ elif self.EntryType != None:
+ code('${ident}_State state = getState(m_cache_entry_ptr, addr);')
+ else:
+ code('${ident}_State state = getState(addr);')
+
+ code('''
${ident}_State next_state = state;
DPRINTF(RubyGenerated, "%s, Time: %lld, state: %s, event: %s, addr: %s\\n",
- *this,
- g_eventQueue_ptr->getTime(),
- ${ident}_State_to_string(state),
- ${ident}_Event_to_string(event),
- addr);
+ *this, curCycle(), ${ident}_State_to_string(state),
+ ${ident}_Event_to_string(event), addr);
TransitionResult result =
- doTransitionWorker(event, state, next_state, addr);
+''')
+ if self.TBEType != None and self.EntryType != None:
+ code('doTransitionWorker(event, state, next_state, m_tbe_ptr, m_cache_entry_ptr, addr);')
+ elif self.TBEType != None:
+ code('doTransitionWorker(event, state, next_state, m_tbe_ptr, addr);')
+ elif self.EntryType != None:
+ code('doTransitionWorker(event, state, next_state, m_cache_entry_ptr, addr);')
+ else:
+ code('doTransitionWorker(event, state, next_state, addr);')
+ code('''
if (result == TransitionResult_Valid) {
DPRINTF(RubyGenerated, "next_state: %s\\n",
${ident}_State_to_string(next_state));
- m_profiler.countTransition(state, event);
- DPRINTFR(ProtocolTrace, "%7d %3s %10s%20s %6s>%-6s %s %s\\n",
- g_eventQueue_ptr->getTime(), m_version, "${ident}",
- ${ident}_Event_to_string(event),
- ${ident}_State_to_string(state),
- ${ident}_State_to_string(next_state),
- addr, GET_TRANSITION_COMMENT());
+ countTransition(state, event);
+ DPRINTFR(ProtocolTrace, "%15d %3s %10s%20s %6s>%-6s %s %s\\n",
+ curTick(), m_version, "${ident}",
+ ${ident}_Event_to_string(event),
+ ${ident}_State_to_string(state),
+ ${ident}_State_to_string(next_state),
+ addr, GET_TRANSITION_COMMENT());
CLEAR_TRANSITION_COMMENT();
- ${ident}_setState(addr, next_state);
+''')
+ if self.TBEType != None and self.EntryType != None:
+ code('setState(m_tbe_ptr, m_cache_entry_ptr, addr, next_state);')
+ code('setAccessPermission(m_cache_entry_ptr, addr, next_state);')
+ elif self.TBEType != None:
+ code('setState(m_tbe_ptr, addr, next_state);')
+ code('setAccessPermission(addr, next_state);')
+ elif self.EntryType != None:
+ code('setState(m_cache_entry_ptr, addr, next_state);')
+ code('setAccessPermission(m_cache_entry_ptr, addr, next_state);')
+ else:
+ code('setState(addr, next_state);')
+ code('setAccessPermission(addr, next_state);')
+
+ code('''
} else if (result == TransitionResult_ResourceStall) {
- DPRINTFR(ProtocolTrace, "%7s %3s %10s%20s %6s>%-6s %s %s\\n",
- g_eventQueue_ptr->getTime(), m_version, "${ident}",
- ${ident}_Event_to_string(event),
- ${ident}_State_to_string(state),
- ${ident}_State_to_string(next_state),
- addr, "Resource Stall");
+ DPRINTFR(ProtocolTrace, "%15s %3s %10s%20s %6s>%-6s %s %s\\n",
+ curTick(), m_version, "${ident}",
+ ${ident}_Event_to_string(event),
+ ${ident}_State_to_string(state),
+ ${ident}_State_to_string(next_state),
+ addr, "Resource Stall");
} else if (result == TransitionResult_ProtocolStall) {
DPRINTF(RubyGenerated, "stalling\\n");
- DPRINTFR(ProtocolTrace, "%7s %3s %10s%20s %6s>%-6s %s %s\\n",
- g_eventQueue_ptr->getTime(), m_version, "${ident}",
- ${ident}_Event_to_string(event),
- ${ident}_State_to_string(state),
- ${ident}_State_to_string(next_state),
- addr, "Protocol Stall");
+ DPRINTFR(ProtocolTrace, "%15s %3s %10s%20s %6s>%-6s %s %s\\n",
+ curTick(), m_version, "${ident}",
+ ${ident}_Event_to_string(event),
+ ${ident}_State_to_string(state),
+ ${ident}_State_to_string(next_state),
+ addr, "Protocol Stall");
}
return result;
${ident}_Controller::doTransitionWorker(${ident}_Event event,
${ident}_State state,
${ident}_State& next_state,
+''')
+
+ if self.TBEType != None:
+ code('''
+ ${{self.TBEType.c_ident}}*& m_tbe_ptr,
+''')
+ if self.EntryType != None:
+ code('''
+ ${{self.EntryType.c_ident}}*& m_cache_entry_ptr,
+''')
+ code('''
const Address& addr)
{
switch(HASH_FUN(state, event)) {
case('next_state = ${ident}_State_${ns_ident};')
actions = trans.actions
+ request_types = trans.request_types
# Check for resources
case_sorter = []
''' % (key.code, val)
case_sorter.append(val)
+ # Check all of the request_types for resource constraints
+ for request_type in request_types:
+ val = '''
+if (!checkResourceAvailable(%s_RequestType_%s, addr)) {
+ return TransitionResult_ResourceStall;
+}
+''' % (self.ident, request_type.ident)
+ case_sorter.append(val)
# Emit the code sequences in a sorted order. This makes the
# output deterministic (without this the output order can vary
for c in sorted(case_sorter):
case("$c")
+ # Record access types for this transition
+ for request_type in request_types:
+ case('recordRequestType(${ident}_RequestType_${{request_type.ident}}, addr);')
+
# Figure out if we stall
stall = False
for action in actions:
if stall:
case('return TransitionResult_ProtocolStall;')
else:
- for action in actions:
- case('${{action.ident}}(addr);')
+ if self.TBEType != None and self.EntryType != None:
+ for action in actions:
+ case('${{action.ident}}(m_tbe_ptr, m_cache_entry_ptr, addr);')
+ elif self.TBEType != None:
+ for action in actions:
+ case('${{action.ident}}(m_tbe_ptr, addr);')
+ elif self.EntryType != None:
+ for action in actions:
+ case('${{action.ident}}(m_cache_entry_ptr, addr);')
+ else:
+ for action in actions:
+ case('${{action.ident}}(addr);')
case('return TransitionResult_Valid;')
case = str(case)
code('''
default:
fatal("Invalid transition\\n"
- "version: %d time: %d addr: %s event: %s state: %s\\n",
- m_version, g_eventQueue_ptr->getTime(), addr, event, state);
+ "%s time: %d addr: %s event: %s state: %s\\n",
+ name(), curCycle(), addr, event, state);
}
return TransitionResult_Valid;
}
''')
code.write(path, "%s_Transitions.cc" % self.ident)
- def printProfileDumperHH(self, path):
- code = self.symtab.codeFormatter()
- ident = self.ident
-
- code('''
-// Auto generated C++ code started by $__file__:$__line__
-// ${ident}: ${{self.short}}
-
-#ifndef __${ident}_PROFILE_DUMPER_HH__
-#define __${ident}_PROFILE_DUMPER_HH__
-
-#include <cassert>
-#include <iostream>
-#include <vector>
-
-#include "${ident}_Profiler.hh"
-#include "${ident}_Event.hh"
-
-typedef std::vector<${ident}_Profiler *> ${ident}_profilers;
-
-class ${ident}_ProfileDumper
-{
- public:
- ${ident}_ProfileDumper();
- void registerProfiler(${ident}_Profiler* profiler);
- void dumpStats(std::ostream& out) const;
-
- private:
- ${ident}_profilers m_profilers;
-};
-
-#endif // __${ident}_PROFILE_DUMPER_HH__
-''')
- code.write(path, "%s_ProfileDumper.hh" % self.ident)
-
- def printProfileDumperCC(self, path):
- code = self.symtab.codeFormatter()
- ident = self.ident
-
- code('''
-// Auto generated C++ code started by $__file__:$__line__
-// ${ident}: ${{self.short}}
-
-#include "mem/protocol/${ident}_ProfileDumper.hh"
-
-${ident}_ProfileDumper::${ident}_ProfileDumper()
-{
-}
-
-void
-${ident}_ProfileDumper::registerProfiler(${ident}_Profiler* profiler)
-{
- m_profilers.push_back(profiler);
-}
-
-void
-${ident}_ProfileDumper::dumpStats(std::ostream& out) const
-{
- out << " --- ${ident} ---\\n";
- out << " - Event Counts -\\n";
- for (${ident}_Event event = ${ident}_Event_FIRST;
- event < ${ident}_Event_NUM;
- ++event) {
- out << (${ident}_Event) event << " [";
- uint64 total = 0;
- for (int i = 0; i < m_profilers.size(); i++) {
- out << m_profilers[i]->getEventCount(event) << " ";
- total += m_profilers[i]->getEventCount(event);
- }
- out << "] " << total << "\\n";
- }
- out << "\\n";
- out << " - Transitions -\\n";
- for (${ident}_State state = ${ident}_State_FIRST;
- state < ${ident}_State_NUM;
- ++state) {
- for (${ident}_Event event = ${ident}_Event_FIRST;
- event < ${ident}_Event_NUM;
- ++event) {
- if (m_profilers[0]->isPossible(state, event)) {
- out << (${ident}_State) state << " "
- << (${ident}_Event) event << " [";
- uint64 total = 0;
- for (int i = 0; i < m_profilers.size(); i++) {
- out << m_profilers[i]->getTransitionCount(state, event) << " ";
- total += m_profilers[i]->getTransitionCount(state, event);
- }
- out << "] " << total << "\\n";
- }
- }
- out << "\\n";
- }
-}
-''')
- code.write(path, "%s_ProfileDumper.cc" % self.ident)
-
- def printProfilerHH(self, path):
- code = self.symtab.codeFormatter()
- ident = self.ident
-
- code('''
-// Auto generated C++ code started by $__file__:$__line__
-// ${ident}: ${{self.short}}
-
-#ifndef __${ident}_PROFILER_HH__
-#define __${ident}_PROFILER_HH__
-
-#include <cassert>
-#include <iostream>
-
-#include "mem/ruby/common/Global.hh"
-#include "mem/protocol/${ident}_State.hh"
-#include "mem/protocol/${ident}_Event.hh"
-
-class ${ident}_Profiler
-{
- public:
- ${ident}_Profiler();
- void setVersion(int version);
- void countTransition(${ident}_State state, ${ident}_Event event);
- void possibleTransition(${ident}_State state, ${ident}_Event event);
- uint64 getEventCount(${ident}_Event event);
- bool isPossible(${ident}_State state, ${ident}_Event event);
- uint64 getTransitionCount(${ident}_State state, ${ident}_Event event);
- void clearStats();
-
- private:
- int m_counters[${ident}_State_NUM][${ident}_Event_NUM];
- int m_event_counters[${ident}_Event_NUM];
- bool m_possible[${ident}_State_NUM][${ident}_Event_NUM];
- int m_version;
-};
-
-#endif // __${ident}_PROFILER_HH__
-''')
- code.write(path, "%s_Profiler.hh" % self.ident)
-
- def printProfilerCC(self, path):
- code = self.symtab.codeFormatter()
- ident = self.ident
-
- code('''
-// Auto generated C++ code started by $__file__:$__line__
-// ${ident}: ${{self.short}}
-
-#include <cassert>
-
-#include "mem/protocol/${ident}_Profiler.hh"
-
-${ident}_Profiler::${ident}_Profiler()
-{
- for (int state = 0; state < ${ident}_State_NUM; state++) {
- for (int event = 0; event < ${ident}_Event_NUM; event++) {
- m_possible[state][event] = false;
- m_counters[state][event] = 0;
- }
- }
- for (int event = 0; event < ${ident}_Event_NUM; event++) {
- m_event_counters[event] = 0;
- }
-}
-
-void
-${ident}_Profiler::setVersion(int version)
-{
- m_version = version;
-}
-
-void
-${ident}_Profiler::clearStats()
-{
- for (int state = 0; state < ${ident}_State_NUM; state++) {
- for (int event = 0; event < ${ident}_Event_NUM; event++) {
- m_counters[state][event] = 0;
- }
- }
-
- for (int event = 0; event < ${ident}_Event_NUM; event++) {
- m_event_counters[event] = 0;
- }
-}
-void
-${ident}_Profiler::countTransition(${ident}_State state, ${ident}_Event event)
-{
- assert(m_possible[state][event]);
- m_counters[state][event]++;
- m_event_counters[event]++;
-}
-void
-${ident}_Profiler::possibleTransition(${ident}_State state,
- ${ident}_Event event)
-{
- m_possible[state][event] = true;
-}
-
-uint64
-${ident}_Profiler::getEventCount(${ident}_Event event)
-{
- return m_event_counters[event];
-}
-
-bool
-${ident}_Profiler::isPossible(${ident}_State state, ${ident}_Event event)
-{
- return m_possible[state][event];
-}
-
-uint64
-${ident}_Profiler::getTransitionCount(${ident}_State state,
- ${ident}_Event event)
-{
- return m_counters[state][event];
-}
-
-''')
- code.write(path, "%s_Profiler.cc" % self.ident)
# **************************
# ******* HTML Files *******
projects / gem5.git / blobdiff