ruby: get rid of ruby's Debug.hh
Get rid of the Debug class Get rid of ASSERT and use assert Use DPRINTFR for ProtocolTrace
This commit is contained in:
Nathan Binkert
parent
8e262adf4f
commit
bd18ac8287
35 changed files with 115 additions and 720 deletions
|
|
@ -50,10 +50,6 @@ def define_options(parser):
|
|||
parser.add_option("--use-map", action="store_true", default=False)
|
||||
parser.add_option("--map-levels", type="int", default=4)
|
||||
|
||||
# ruby debug cmd line options
|
||||
parser.add_option("--ruby-debug", action="store_true", default=False)
|
||||
parser.add_option("--ruby-debug-cycle", type="int", default=1)
|
||||
|
||||
parser.add_option("--recycle-latency", type="int", default=10,
|
||||
help="Recycle latency for ruby controller input buffers")
|
||||
|
||||
|
|
@ -131,10 +127,6 @@ def create_system(options, system, piobus = None, dma_devices = []):
|
|||
network = network,
|
||||
profiler = ruby_profiler,
|
||||
tracer = RubyTracer(),
|
||||
debug = RubyDebug(filter_string = 'none',
|
||||
verbosity_string = 'none',
|
||||
protocol_trace = options.ruby_debug,
|
||||
start_time = options.ruby_debug_cycle),
|
||||
mem_size = total_mem_size)
|
||||
|
||||
ruby.cpu_ruby_ports = cpu_sequencers
|
||||
|
|
|
|||
|
|
@ -60,6 +60,7 @@ TraceFlag('LLSC')
|
|||
TraceFlag('MMU')
|
||||
TraceFlag('MemoryAccess')
|
||||
|
||||
TraceFlag('ProtocolTrace')
|
||||
TraceFlag('RubyCache')
|
||||
TraceFlag('RubyDma')
|
||||
TraceFlag('RubyGenerated')
|
||||
|
|
|
|||
|
|
@ -26,6 +26,8 @@
|
|||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include <cassert>
|
||||
|
||||
#include "base/cprintf.hh"
|
||||
#include "base/misc.hh"
|
||||
#include "base/stl_helpers.hh"
|
||||
|
|
@ -158,7 +160,7 @@ MessageBuffer::enqueue(MsgPtr message, Time delta)
|
|||
}
|
||||
m_msgs_this_cycle++;
|
||||
|
||||
// ASSERT(m_max_size == -1 || m_size <= m_max_size + 1);
|
||||
// assert(m_max_size == -1 || m_size <= m_max_size + 1);
|
||||
// the plus one is a kluge because of a SLICC issue
|
||||
|
||||
if (!m_ordering_set) {
|
||||
|
|
|
|||
|
|
@ -35,6 +35,7 @@
|
|||
#define __MEM_RUBY_BUFFERS_MESSAGEBUFFER_HH__
|
||||
|
||||
#include <algorithm>
|
||||
#include <cassert>
|
||||
#include <functional>
|
||||
#include <iostream>
|
||||
#include <vector>
|
||||
|
|
@ -85,7 +86,7 @@ class MessageBuffer
|
|||
void setPriority(int rank) { m_priority_rank = rank; }
|
||||
void setConsumer(Consumer* consumer_ptr)
|
||||
{
|
||||
ASSERT(m_consumer_ptr == NULL);
|
||||
assert(m_consumer_ptr == NULL);
|
||||
m_consumer_ptr = consumer_ptr;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1,338 +0,0 @@
|
|||
/*
|
||||
* Copyright (c) 1999-2008 Mark D. Hill and David A. Wood
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions are
|
||||
* met: redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer;
|
||||
* redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution;
|
||||
* neither the name of the copyright holders nor the names of its
|
||||
* contributors may be used to endorse or promote products derived from
|
||||
* this software without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include <fstream>
|
||||
#include <stdarg.h>
|
||||
|
||||
#include "base/misc.hh"
|
||||
#include "mem/ruby/common/Debug.hh"
|
||||
#include "mem/ruby/common/Global.hh"
|
||||
#include "mem/ruby/eventqueue/RubyEventQueue.hh"
|
||||
|
||||
using namespace std;
|
||||
|
||||
class Debug;
|
||||
extern Debug* g_debug_ptr;
|
||||
ostream *debug_cout_ptr;
|
||||
|
||||
bool Debug::m_protocol_trace = false;
|
||||
struct DebugComponentData
|
||||
{
|
||||
const char *desc;
|
||||
const char ch;
|
||||
};
|
||||
|
||||
// component character list
|
||||
DebugComponentData debugComponents[] =
|
||||
{
|
||||
{"System", 's' },
|
||||
{"Node", 'N' },
|
||||
{"Queue", 'q' },
|
||||
{"Event Queue", 'e' },
|
||||
{"Network", 'n' },
|
||||
{"Sequencer", 'S' },
|
||||
{"Tester", 't' },
|
||||
{"Generated", 'g' },
|
||||
{"SLICC", 'l' },
|
||||
{"Network Queues", 'Q' },
|
||||
{"Time", 'T' },
|
||||
{"Network Internals", 'i' },
|
||||
{"Store Buffer", 'b' },
|
||||
{"Cache", 'c' },
|
||||
{"Predictor", 'p' },
|
||||
{"Memory", 'M' },
|
||||
};
|
||||
|
||||
extern "C" void changeDebugVerbosity(VerbosityLevel vb);
|
||||
extern "C" void changeDebugFilter(int filter);
|
||||
|
||||
void
|
||||
changeDebugVerbosity(VerbosityLevel vb)
|
||||
{
|
||||
g_debug_ptr->setVerbosity(vb);
|
||||
}
|
||||
|
||||
void
|
||||
changeDebugFilter(int filter)
|
||||
{
|
||||
g_debug_ptr->setFilter(filter);
|
||||
}
|
||||
|
||||
Debug::Debug(const Params *p)
|
||||
: SimObject(p)
|
||||
{
|
||||
clearFilter();
|
||||
debug_cout_ptr = &cout;
|
||||
|
||||
setFilterString(p->filter_string.c_str());
|
||||
setVerbosityString(p->verbosity_string.c_str());
|
||||
setDebugOutputFile(p->output_filename.c_str());
|
||||
m_starting_cycle = p->start_time;
|
||||
m_protocol_trace = p->protocol_trace;
|
||||
g_debug_ptr = this;
|
||||
}
|
||||
|
||||
Debug::~Debug()
|
||||
{
|
||||
}
|
||||
|
||||
void
|
||||
Debug::printVerbosity(ostream& out) const
|
||||
{
|
||||
switch (getVerbosity()) {
|
||||
case No_Verb:
|
||||
out << "verbosity = No_Verb" << endl;
|
||||
break;
|
||||
case Low_Verb:
|
||||
out << "verbosity = Low_Verb" << endl;
|
||||
break;
|
||||
case Med_Verb:
|
||||
out << "verbosity = Med_Verb" << endl;
|
||||
break;
|
||||
case High_Verb:
|
||||
out << "verbosity = High_Verb" << endl;
|
||||
break;
|
||||
default:
|
||||
out << "verbosity = unknown" << endl;
|
||||
}
|
||||
}
|
||||
|
||||
bool
|
||||
Debug::validDebug(int module, PriorityLevel priority)
|
||||
{
|
||||
int local_module = (1 << module);
|
||||
if (m_filter & local_module) {
|
||||
if (g_eventQueue_ptr == NULL ||
|
||||
g_eventQueue_ptr->getTime() >= m_starting_cycle) {
|
||||
switch (m_verbosityLevel) {
|
||||
case No_Verb:
|
||||
return false;
|
||||
case Low_Verb:
|
||||
return (priority == HighPrio);
|
||||
case Med_Verb:
|
||||
return (priority == HighPrio || priority == MedPrio);
|
||||
case High_Verb:
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
void
|
||||
Debug::setDebugTime(Time t)
|
||||
{
|
||||
m_starting_cycle = t;
|
||||
}
|
||||
|
||||
void
|
||||
Debug::setVerbosity(VerbosityLevel vb)
|
||||
{
|
||||
m_verbosityLevel = vb;
|
||||
}
|
||||
|
||||
void
|
||||
Debug::setFilter(int filter)
|
||||
{
|
||||
m_filter = filter;
|
||||
}
|
||||
|
||||
bool
|
||||
Debug::setVerbosityString(const char *verb_str)
|
||||
{
|
||||
string verb = verb_str ? verb_str : "";
|
||||
if (verb == "none") {
|
||||
setVerbosity(No_Verb);
|
||||
} else if (verb == "low") {
|
||||
setVerbosity(Low_Verb);
|
||||
} else if (verb == "med") {
|
||||
setVerbosity(Med_Verb);
|
||||
} else if (verb == "high") {
|
||||
setVerbosity(High_Verb);
|
||||
} else {
|
||||
cerr << "Error: unrecognized verbosity (use none, low, med, high): "
|
||||
<< verb << endl;
|
||||
return true; // error
|
||||
}
|
||||
return false; // no error
|
||||
}
|
||||
|
||||
bool
|
||||
Debug::checkFilter(char ch)
|
||||
{
|
||||
for (int i = 0; i < NUMBER_OF_COMPS; i++) {
|
||||
// Look at all components to find a character match
|
||||
if (debugComponents[i].ch == ch) {
|
||||
// We found a match - return no error
|
||||
return false; // no error
|
||||
}
|
||||
}
|
||||
return true; // error
|
||||
}
|
||||
|
||||
bool
|
||||
Debug::checkFilterString(const char *filter_str)
|
||||
{
|
||||
if (filter_str == NULL) {
|
||||
cerr << "Error: unrecognized component filter: NULL" << endl;
|
||||
return true; // error
|
||||
}
|
||||
|
||||
// check for default filter ("none") before reporting RUBY_DEBUG error
|
||||
if (string(filter_str) == "none") {
|
||||
return false; // no error
|
||||
}
|
||||
|
||||
if (string(filter_str) == "all") {
|
||||
return false; // no error
|
||||
}
|
||||
|
||||
// scan string checking each character
|
||||
for (unsigned int i = 0; i < strlen(filter_str); i++) {
|
||||
bool unrecognized = checkFilter(filter_str[i]);
|
||||
if (unrecognized == true) {
|
||||
return true; // error
|
||||
}
|
||||
}
|
||||
return false; // no error
|
||||
}
|
||||
|
||||
bool
|
||||
Debug::setFilterString(const char *filter_str)
|
||||
{
|
||||
if (checkFilterString(filter_str)) {
|
||||
return true; // error
|
||||
}
|
||||
|
||||
if (string(filter_str) == "all" ) {
|
||||
allFilter();
|
||||
} else if (string(filter_str) == "none") {
|
||||
clearFilter();
|
||||
} else {
|
||||
// scan string adding to bit mask for each component which is present
|
||||
for (unsigned int i = 0; i < strlen(filter_str); i++) {
|
||||
bool error = addFilter( filter_str[i] );
|
||||
if (error) {
|
||||
return true; // error
|
||||
}
|
||||
}
|
||||
}
|
||||
return false; // no error
|
||||
}
|
||||
|
||||
bool
|
||||
Debug::addFilter(char ch)
|
||||
{
|
||||
for (int i = 0; i < NUMBER_OF_COMPS; i++) {
|
||||
// Look at all components to find a character match
|
||||
if (debugComponents[i].ch == ch) {
|
||||
// We found a match - update the filter bit mask
|
||||
cout << " Debug: Adding to filter: '" << ch << "' ("
|
||||
<< debugComponents[i].desc << ")" << endl;
|
||||
m_filter |= (1 << i);
|
||||
return false; // no error
|
||||
}
|
||||
}
|
||||
|
||||
// We didn't find the character
|
||||
cerr << "Error: unrecognized component filter: " << ch << endl;
|
||||
usageInstructions();
|
||||
return true; // error
|
||||
}
|
||||
|
||||
void
|
||||
Debug::clearFilter()
|
||||
{
|
||||
m_filter = 0;
|
||||
}
|
||||
|
||||
void Debug::allFilter()
|
||||
{
|
||||
m_filter = ~0;
|
||||
}
|
||||
|
||||
void
|
||||
Debug::usageInstructions(void)
|
||||
{
|
||||
cerr << "Debug components: " << endl;
|
||||
for (int i = 0; i < NUMBER_OF_COMPS; i++) {
|
||||
cerr << " " << debugComponents[i].ch << ": "
|
||||
<< debugComponents[i].desc << endl;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
Debug::print(ostream& out) const
|
||||
{
|
||||
out << "[Debug]" << endl;
|
||||
}
|
||||
|
||||
void
|
||||
Debug::setDebugOutputFile (const char *filename)
|
||||
{
|
||||
if (filename == NULL || !strcmp(filename, "none")) {
|
||||
debug_cout_ptr = &cout;
|
||||
return;
|
||||
}
|
||||
|
||||
if (m_fout.is_open()) {
|
||||
m_fout.close();
|
||||
}
|
||||
m_fout.open(filename, ios::out);
|
||||
if (!m_fout.is_open()) {
|
||||
cerr << "setDebugOutputFile: can't open file " << filename << endl;
|
||||
} else {
|
||||
debug_cout_ptr = &m_fout;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
Debug::closeDebugOutputFile ()
|
||||
{
|
||||
if (m_fout.is_open()) {
|
||||
m_fout.close ();
|
||||
debug_cout_ptr = &cout;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
Debug::debugMsg( const char *fmt, ...)
|
||||
{
|
||||
va_list args;
|
||||
|
||||
// you could check validDebug() here before printing the message
|
||||
va_start(args, fmt);
|
||||
vfprintf(stdout, fmt, args);
|
||||
va_end(args);
|
||||
}
|
||||
|
||||
Debug *
|
||||
RubyDebugParams::create()
|
||||
{
|
||||
return new Debug(this);
|
||||
}
|
||||
|
|
@ -1,162 +0,0 @@
|
|||
/*
|
||||
* Copyright (c) 1999-2008 Mark D. Hill and David A. Wood
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions are
|
||||
* met: redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer;
|
||||
* redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution;
|
||||
* neither the name of the copyright holders nor the names of its
|
||||
* contributors may be used to endorse or promote products derived from
|
||||
* this software without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#ifndef __MEM_RUBY_COMMON_DEBUG_HH__
|
||||
#define __MEM_RUBY_COMMON_DEBUG_HH__
|
||||
|
||||
#include <unistd.h>
|
||||
|
||||
#include <fstream>
|
||||
#include <iostream>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
#include "mem/ruby/common/Global.hh"
|
||||
#include "sim/sim_object.hh"
|
||||
|
||||
#include "params/RubyDebug.hh"
|
||||
|
||||
extern std::ostream * debug_cout_ptr;
|
||||
|
||||
// component enumeration
|
||||
enum DebugComponents
|
||||
{
|
||||
SYSTEM_COMP,
|
||||
NODE_COMP,
|
||||
QUEUE_COMP,
|
||||
EVENTQUEUE_COMP,
|
||||
NETWORK_COMP,
|
||||
SEQUENCER_COMP,
|
||||
TESTER_COMP,
|
||||
GENERATED_COMP,
|
||||
SLICC_COMP,
|
||||
NETWORKQUEUE_COMP,
|
||||
TIME_COMP,
|
||||
NETWORK_INTERNALS_COMP,
|
||||
STOREBUFFER_COMP,
|
||||
CACHE_COMP,
|
||||
PREDICTOR_COMP,
|
||||
MEMORY_COMP,
|
||||
NUMBER_OF_COMPS
|
||||
};
|
||||
|
||||
enum PriorityLevel {HighPrio, MedPrio, LowPrio};
|
||||
enum VerbosityLevel {No_Verb, Low_Verb, Med_Verb, High_Verb};
|
||||
|
||||
class Debug : public SimObject
|
||||
{
|
||||
public:
|
||||
typedef RubyDebugParams Params;
|
||||
Debug(const Params *p);
|
||||
~Debug();
|
||||
|
||||
static bool getProtocolTrace() { return m_protocol_trace; }
|
||||
bool validDebug(int module, PriorityLevel priority);
|
||||
void printVerbosity(std::ostream& out) const;
|
||||
void setVerbosity(VerbosityLevel vb);
|
||||
bool setVerbosityString(const char *);
|
||||
VerbosityLevel getVerbosity() const { return m_verbosityLevel; }
|
||||
void setFilter(int);
|
||||
static bool checkFilter( char);
|
||||
static bool checkFilterString(const char *);
|
||||
bool setFilterString(const char *);
|
||||
void setDebugTime(Time);
|
||||
Time getDebugTime() const { return m_starting_cycle; }
|
||||
bool addFilter(char);
|
||||
void clearFilter();
|
||||
void allFilter();
|
||||
void print(std::ostream& out) const;
|
||||
/* old school debugging "vararg": sends messages to screen and log */
|
||||
void debugMsg(const char *fmt, ...);
|
||||
|
||||
void setDebugOutputFile (const char * filename);
|
||||
void closeDebugOutputFile ();
|
||||
static void usageInstructions(void);
|
||||
|
||||
private:
|
||||
// Private copy constructor and assignment operator
|
||||
Debug(const Debug& obj);
|
||||
Debug& operator=(const Debug& obj);
|
||||
|
||||
static bool m_protocol_trace;
|
||||
VerbosityLevel m_verbosityLevel;
|
||||
int m_filter;
|
||||
Time m_starting_cycle;
|
||||
|
||||
std::fstream m_fout;
|
||||
};
|
||||
|
||||
inline std::ostream&
|
||||
operator<<(std::ostream& out, const Debug& obj)
|
||||
{
|
||||
obj.print(out);
|
||||
out << std::flush;
|
||||
return out;
|
||||
}
|
||||
|
||||
#undef assert
|
||||
#define assert(EXPR) ASSERT(EXPR)
|
||||
#undef ASSERT
|
||||
|
||||
#ifndef NDEBUG
|
||||
|
||||
#define ASSERT(EXPR) do { \
|
||||
using namespace std; \
|
||||
if (!(EXPR)) { \
|
||||
cerr << "failed assertion '" \
|
||||
<< #EXPR << "' at fn " \
|
||||
<< __PRETTY_FUNCTION__ << " in " \
|
||||
<< __FILE__ << ":" \
|
||||
<< __LINE__ << endl << flush; \
|
||||
(*debug_cout_ptr) << "failed assertion '" \
|
||||
<< #EXPR << "' at fn " \
|
||||
<< __PRETTY_FUNCTION__ << " in " \
|
||||
<< __FILE__ << ":" \
|
||||
<< __LINE__ << endl << flush; \
|
||||
if (isatty(STDIN_FILENO)) { \
|
||||
cerr << "At this point you might want to attach a debug to " \
|
||||
<< "the running and get to the" << endl \
|
||||
<< "crash site; otherwise press enter to continue" \
|
||||
<< endl \
|
||||
<< "PID: " << getpid() \
|
||||
<< endl << flush; \
|
||||
char c; \
|
||||
cin.get(c); \
|
||||
} \
|
||||
abort(); \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
#else
|
||||
|
||||
#define ASSERT(EXPR) do {} while (0)
|
||||
|
||||
#endif // NDEBUG
|
||||
|
||||
#endif // __MEM_RUBY_COMMON_DEBUG_HH__
|
||||
|
||||
|
|
@ -1,52 +0,0 @@
|
|||
# Copyright (c) 2009 Advanced Micro Devices, Inc.
|
||||
# All rights reserved.
|
||||
#
|
||||
# Redistribution and use in source and binary forms, with or without
|
||||
# modification, are permitted provided that the following conditions are
|
||||
# met: redistributions of source code must retain the above copyright
|
||||
# notice, this list of conditions and the following disclaimer;
|
||||
# redistributions in binary form must reproduce the above copyright
|
||||
# notice, this list of conditions and the following disclaimer in the
|
||||
# documentation and/or other materials provided with the distribution;
|
||||
# neither the name of the copyright holders nor the names of its
|
||||
# contributors may be used to endorse or promote products derived from
|
||||
# this software without specific prior written permission.
|
||||
#
|
||||
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
#
|
||||
# Authors: Steve Reinhardt
|
||||
# Brad Beckmann
|
||||
|
||||
from m5.params import *
|
||||
from m5.SimObject import SimObject
|
||||
|
||||
class RubyDebug(SimObject):
|
||||
type = 'RubyDebug'
|
||||
cxx_class = 'Debug'
|
||||
|
||||
filter_string = Param.String('none',
|
||||
"a string for filtering debugging output (see Debug.h)")
|
||||
verbosity_string = Param.String('none',
|
||||
"filters debugging messages based on priority (low, med, high)")
|
||||
output_filename = Param.String('none',
|
||||
"sends debugging messages to a file")
|
||||
start_time = Param.Tick(1,
|
||||
"filters debugging messages based on a ruby time")
|
||||
# For debugging purposes, one can enable a trace of all the protocol
|
||||
# state machine changes. Unfortunately, the code to generate the
|
||||
# trace is protocol specific. To enable the code for some of the
|
||||
# standard protocols,
|
||||
# 1. change protocol_trace = true
|
||||
# 2. enable debug in the Ruby Makefile
|
||||
protocol_trace = Param.Bool(False,
|
||||
"enable protocol state machine trace")
|
||||
|
|
@ -28,7 +28,6 @@
|
|||
|
||||
#include "mem/ruby/common/Global.hh"
|
||||
|
||||
RubyEventQueue* g_eventQueue_ptr = NULL;
|
||||
RubySystem* g_system_ptr = NULL;
|
||||
Debug* g_debug_ptr = NULL;
|
||||
RubyEventQueue* g_eventQueue_ptr = 0;
|
||||
RubySystem* g_system_ptr = 0;
|
||||
|
||||
|
|
|
|||
|
|
@ -31,7 +31,6 @@
|
|||
|
||||
// external includes for all classes
|
||||
#include "mem/ruby/common/TypeDefines.hh"
|
||||
#include "mem/ruby/common/Debug.hh"
|
||||
|
||||
// simple type declarations
|
||||
typedef Time LogicalTime;
|
||||
|
|
@ -47,9 +46,6 @@ extern RubyEventQueue* g_eventQueue_ptr;
|
|||
class RubySystem;
|
||||
extern RubySystem* g_system_ptr;
|
||||
|
||||
class Debug;
|
||||
extern Debug* g_debug_ptr;
|
||||
|
||||
// FIXME: this is required by the contructor of Directory_Entry.hh.
|
||||
// It can't go into slicc_util.hh because it opens a can of ugly worms
|
||||
extern inline int max_tokens()
|
||||
|
|
|
|||
|
|
@ -33,11 +33,8 @@ Import('*')
|
|||
if not env['RUBY']:
|
||||
Return()
|
||||
|
||||
SimObject('Debug.py')
|
||||
|
||||
Source('Address.cc')
|
||||
Source('DataBlock.cc')
|
||||
Source('Debug.cc')
|
||||
Source('Driver.cc')
|
||||
Source('Global.cc')
|
||||
Source('Histogram.cc')
|
||||
|
|
|
|||
|
|
@ -29,6 +29,8 @@
|
|||
// modified (rewritten) 05/20/05 by Dan Gibson to accomimdate FASTER
|
||||
// >32 bit set sizes
|
||||
|
||||
#include <cstdio>
|
||||
|
||||
#include "base/misc.hh"
|
||||
#include "mem/ruby/common/Set.hh"
|
||||
#include "mem/ruby/system/System.hh"
|
||||
|
|
|
|||
|
|
@ -26,6 +26,8 @@
|
|||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include <cassert>
|
||||
|
||||
#include "mem/ruby/common/Consumer.hh"
|
||||
#include "mem/ruby/eventqueue/RubyEventQueue.hh"
|
||||
#include "mem/ruby/eventqueue/RubyEventQueueNode.hh"
|
||||
|
|
@ -50,7 +52,7 @@ void
|
|||
RubyEventQueue::scheduleEventAbsolute(Consumer* consumer, Time timeAbs)
|
||||
{
|
||||
// Check to see if this is a redundant wakeup
|
||||
ASSERT(consumer != NULL);
|
||||
assert(consumer != NULL);
|
||||
if (!consumer->alreadyScheduled(timeAbs)) {
|
||||
// This wakeup is not redundant
|
||||
RubyEventQueueNode *thisNode = new RubyEventQueueNode(consumer, this);
|
||||
|
|
|
|||
|
|
@ -26,6 +26,8 @@
|
|||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include <cassert>
|
||||
|
||||
#include "base/intmath.hh"
|
||||
#include "base/str.hh"
|
||||
#include "mem/ruby/filters/BulkBloomFilter.hh"
|
||||
|
|
@ -98,9 +100,9 @@ BulkBloomFilter::set(const Address& addr)
|
|||
//Address permuted_bits = permute(addr);
|
||||
//int c1 = permuted_bits.bitSelect(0, set_bits-1);
|
||||
int c1 = addr.bitSelect( block_bits+set_bits, (block_bits+2*set_bits) - 1);
|
||||
//ASSERT(c0 < (m_filter_size/2));
|
||||
//ASSERT(c0 + (m_filter_size/2) < m_filter_size);
|
||||
//ASSERT(c1 < (m_filter_size/2));
|
||||
//assert(c0 < (m_filter_size/2));
|
||||
//assert(c0 + (m_filter_size/2) < m_filter_size);
|
||||
//assert(c1 < (m_filter_size/2));
|
||||
// set v0 bit
|
||||
m_filter[c0 + (m_filter_size/2)] = 1;
|
||||
// set v1 bit
|
||||
|
|
@ -124,9 +126,9 @@ BulkBloomFilter::isSet(const Address& addr)
|
|||
//Address permuted_bits = permute(addr);
|
||||
//int c1 = permuted_bits.bitSelect(0, set_bits-1);
|
||||
int c1 = addr.bitSelect( block_bits+set_bits, (block_bits+2*set_bits) - 1);
|
||||
//ASSERT(c0 < (m_filter_size/2));
|
||||
//ASSERT(c0 + (m_filter_size/2) < m_filter_size);
|
||||
//ASSERT(c1 < (m_filter_size/2));
|
||||
//assert(c0 < (m_filter_size/2));
|
||||
//assert(c0 + (m_filter_size/2) < m_filter_size);
|
||||
//assert(c1 < (m_filter_size/2));
|
||||
// set v0 bit
|
||||
m_temp_filter[c0 + (m_filter_size/2)] = 1;
|
||||
// set v1 bit
|
||||
|
|
|
|||
|
|
@ -28,6 +28,8 @@
|
|||
* Authors: Niket Agarwal
|
||||
*/
|
||||
|
||||
#include <cassert>
|
||||
|
||||
#include "base/stl_helpers.hh"
|
||||
#include "mem/ruby/network/garnet/fixed-pipeline/GarnetNetwork_d.hh"
|
||||
#include "mem/protocol/MachineType.hh"
|
||||
|
|
@ -223,8 +225,8 @@ void
|
|||
GarnetNetwork_d::checkNetworkAllocation(NodeID id, bool ordered,
|
||||
int network_num)
|
||||
{
|
||||
ASSERT(id < m_nodes);
|
||||
ASSERT(network_num < m_virtual_networks);
|
||||
assert(id < m_nodes);
|
||||
assert(network_num < m_virtual_networks);
|
||||
|
||||
if (ordered) {
|
||||
m_ordered[network_num] = true;
|
||||
|
|
|
|||
|
|
@ -28,6 +28,7 @@
|
|||
* Authors: Niket Agarwal
|
||||
*/
|
||||
|
||||
#include <cassert>
|
||||
#include <cmath>
|
||||
|
||||
#include "base/stl_helpers.hh"
|
||||
|
|
@ -105,7 +106,7 @@ void
|
|||
NetworkInterface_d::addNode(vector<MessageBuffer *>& in,
|
||||
vector<MessageBuffer *>& out)
|
||||
{
|
||||
ASSERT(in.size() == m_virtual_networks);
|
||||
assert(in.size() == m_virtual_networks);
|
||||
inNode_ptr = in;
|
||||
outNode_ptr = out;
|
||||
for (int j = 0; j < m_virtual_networks; j++) {
|
||||
|
|
|
|||
|
|
@ -31,6 +31,7 @@
|
|||
#ifndef __MEM_RUBY_NETWORK_GARNET_FIXED_PIPELINE_FLIT_D_HH__
|
||||
#define __MEM_RUBY_NETWORK_GARNET_FIXED_PIPELINE_FLIT_D_HH__
|
||||
|
||||
#include <cassert>
|
||||
#include <iostream>
|
||||
|
||||
#include "mem/ruby/network/garnet/NetworkHeader.hh"
|
||||
|
|
@ -98,7 +99,7 @@ class flit_d
|
|||
greater(flit_d* n1, flit_d* n2)
|
||||
{
|
||||
if (n1->get_time() == n2->get_time()) {
|
||||
//ASSERT(n1->flit_id != n2->flit_id);
|
||||
//assert(n1->flit_id != n2->flit_id);
|
||||
return (n1->get_id() > n2->get_id());
|
||||
} else {
|
||||
return (n1->get_time() > n2->get_time());
|
||||
|
|
|
|||
|
|
@ -28,6 +28,9 @@
|
|||
* Authors: Niket Agarwal
|
||||
*/
|
||||
|
||||
#include <cassert>
|
||||
|
||||
#include "base/cprintf.hh"
|
||||
#include "base/stl_helpers.hh"
|
||||
#include "mem/ruby/network/garnet/flexible-pipeline/GarnetNetwork.hh"
|
||||
#include "mem/protocol/MachineType.hh"
|
||||
|
|
@ -188,9 +191,9 @@ void
|
|||
GarnetNetwork::checkNetworkAllocation(NodeID id, bool ordered,
|
||||
int network_num)
|
||||
{
|
||||
printf ("id = %i, m_nodes = %i \n", id, m_nodes);
|
||||
ASSERT(id < m_nodes);
|
||||
ASSERT(network_num < m_virtual_networks);
|
||||
cprintf ("id = %i, m_nodes = %i \n", id, m_nodes);
|
||||
assert(id < m_nodes);
|
||||
assert(network_num < m_virtual_networks);
|
||||
|
||||
if (ordered) {
|
||||
m_ordered[network_num] = true;
|
||||
|
|
|
|||
|
|
@ -28,6 +28,7 @@
|
|||
* Authors: Niket Agarwal
|
||||
*/
|
||||
|
||||
#include <cassert>
|
||||
#include <cmath>
|
||||
|
||||
#include "base/stl_helpers.hh"
|
||||
|
|
@ -95,7 +96,7 @@ void
|
|||
NetworkInterface::addNode(vector<MessageBuffer*>& in,
|
||||
vector<MessageBuffer*>& out)
|
||||
{
|
||||
ASSERT(in.size() == m_virtual_networks);
|
||||
assert(in.size() == m_virtual_networks);
|
||||
inNode_ptr = in;
|
||||
outNode_ptr = out;
|
||||
|
||||
|
|
|
|||
|
|
@ -28,6 +28,7 @@
|
|||
* Authors: Niket Agarwal
|
||||
*/
|
||||
|
||||
#include <cassert>
|
||||
#include <iostream>
|
||||
|
||||
#include "mem/ruby/network/garnet/NetworkHeader.hh"
|
||||
|
|
@ -57,7 +58,7 @@ class flit
|
|||
greater(flit* n1, flit* n2)
|
||||
{
|
||||
if (n1->get_time() == n2->get_time())
|
||||
//ASSERT(n1->flit_id != n2->flit_id);
|
||||
//assert(n1->flit_id != n2->flit_id);
|
||||
return (n1->get_id() > n2->get_id());
|
||||
else
|
||||
return (n1->get_time() > n2->get_time());
|
||||
|
|
|
|||
|
|
@ -26,6 +26,7 @@
|
|||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include <cassert>
|
||||
#include <numeric>
|
||||
|
||||
#include "base/stl_helpers.hh"
|
||||
|
|
@ -198,8 +199,8 @@ SimpleNetwork::makeInternalLink(SwitchID src, SwitchID dest,
|
|||
void
|
||||
SimpleNetwork::checkNetworkAllocation(NodeID id, bool ordered, int network_num)
|
||||
{
|
||||
ASSERT(id < m_nodes);
|
||||
ASSERT(network_num < m_virtual_networks);
|
||||
assert(id < m_nodes);
|
||||
assert(network_num < m_virtual_networks);
|
||||
|
||||
if (ordered) {
|
||||
m_ordered[network_num] = true;
|
||||
|
|
|
|||
|
|
@ -26,6 +26,8 @@
|
|||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include <cassert>
|
||||
|
||||
#include "base/cprintf.hh"
|
||||
#include "mem/protocol/Protocol.hh"
|
||||
#include "mem/ruby/buffers/MessageBuffer.hh"
|
||||
|
|
@ -45,8 +47,6 @@ const int PRIORITY_SWITCH_LIMIT = 128;
|
|||
|
||||
static int network_message_to_size(NetworkMessage* net_msg_ptr);
|
||||
|
||||
extern ostream *debug_cout_ptr;
|
||||
|
||||
Throttle::Throttle(int sID, NodeID node, int link_latency,
|
||||
int link_bandwidth_multiplier)
|
||||
{
|
||||
|
|
@ -67,7 +67,7 @@ Throttle::init(NodeID node, int link_latency, int link_bandwidth_multiplier)
|
|||
m_node = node;
|
||||
m_vnets = 0;
|
||||
|
||||
ASSERT(link_bandwidth_multiplier > 0);
|
||||
assert(link_bandwidth_multiplier > 0);
|
||||
m_link_bandwidth_multiplier = link_bandwidth_multiplier;
|
||||
m_link_latency = link_latency;
|
||||
|
||||
|
|
|
|||
|
|
@ -26,6 +26,8 @@
|
|||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include <cassert>
|
||||
|
||||
#include "mem/protocol/MachineType.hh"
|
||||
#include "mem/protocol/Protocol.hh"
|
||||
#include "mem/protocol/TopologyType.hh"
|
||||
|
|
@ -224,8 +226,8 @@ void
|
|||
Topology::addLink(SwitchID src, SwitchID dest, int link_latency,
|
||||
int bw_multiplier, int link_weight)
|
||||
{
|
||||
ASSERT(src <= m_number_of_switches+m_nodes+m_nodes);
|
||||
ASSERT(dest <= m_number_of_switches+m_nodes+m_nodes);
|
||||
assert(src <= m_number_of_switches+m_nodes+m_nodes);
|
||||
assert(dest <= m_number_of_switches+m_nodes+m_nodes);
|
||||
m_links_src_vector.push_back(src);
|
||||
m_links_dest_vector.push_back(dest);
|
||||
m_links_latency_vector.push_back(link_latency);
|
||||
|
|
|
|||
|
|
@ -47,13 +47,13 @@
|
|||
#include <sys/times.h>
|
||||
|
||||
#include <algorithm>
|
||||
#include <fstream>
|
||||
|
||||
#include "base/stl_helpers.hh"
|
||||
#include "base/str.hh"
|
||||
#include "mem/protocol/CacheMsg.hh"
|
||||
#include "mem/protocol/MachineType.hh"
|
||||
#include "mem/protocol/Protocol.hh"
|
||||
#include "mem/ruby/common/Debug.hh"
|
||||
#include "mem/ruby/network/Network.hh"
|
||||
#include "mem/ruby/profiler/AddressProfiler.hh"
|
||||
#include "mem/ruby/profiler/Profiler.hh"
|
||||
|
|
@ -63,8 +63,6 @@
|
|||
using namespace std;
|
||||
using m5::stl_helpers::operator<<;
|
||||
|
||||
extern ostream* debug_cout_ptr;
|
||||
|
||||
static double process_memory_total();
|
||||
static double process_memory_resident();
|
||||
|
||||
|
|
@ -697,39 +695,6 @@ Profiler::swPrefetchLatency(Time cycles,
|
|||
}
|
||||
}
|
||||
|
||||
void
|
||||
Profiler::profileTransition(const string& component, NodeID version,
|
||||
Address addr, const string& state, const string& event,
|
||||
const string& next_state, const string& note)
|
||||
{
|
||||
const int EVENT_SPACES = 20;
|
||||
const int ID_SPACES = 3;
|
||||
const int TIME_SPACES = 7;
|
||||
const int COMP_SPACES = 10;
|
||||
const int STATE_SPACES = 6;
|
||||
|
||||
if (g_debug_ptr->getDebugTime() <= 0 ||
|
||||
g_eventQueue_ptr->getTime() < g_debug_ptr->getDebugTime())
|
||||
return;
|
||||
|
||||
ostream &out = *debug_cout_ptr;
|
||||
out.flags(ios::right);
|
||||
out << setw(TIME_SPACES) << g_eventQueue_ptr->getTime() << " ";
|
||||
out << setw(ID_SPACES) << version << " ";
|
||||
out << setw(COMP_SPACES) << component;
|
||||
out << setw(EVENT_SPACES) << event << " ";
|
||||
|
||||
out.flags(ios::right);
|
||||
out << setw(STATE_SPACES) << state;
|
||||
out << ">";
|
||||
out.flags(ios::left);
|
||||
out << setw(STATE_SPACES) << next_state;
|
||||
|
||||
out << " " << addr << " " << note;
|
||||
|
||||
out << endl;
|
||||
}
|
||||
|
||||
// Helper function
|
||||
static double
|
||||
process_memory_total()
|
||||
|
|
@ -764,15 +729,9 @@ Profiler::rubyWatch(int id)
|
|||
{
|
||||
uint64 tr = 0;
|
||||
Address watch_address = Address(tr);
|
||||
const int ID_SPACES = 3;
|
||||
const int TIME_SPACES = 7;
|
||||
|
||||
ostream &out = *debug_cout_ptr;
|
||||
|
||||
out.flags(ios::right);
|
||||
out << setw(TIME_SPACES) << g_eventQueue_ptr->getTime() << " ";
|
||||
out << setw(ID_SPACES) << id << " "
|
||||
<< "RUBY WATCH " << watch_address << endl;
|
||||
DPRINTFN("%7s %3s RUBY WATCH %d\n", g_eventQueue_ptr->getTime(), id,
|
||||
watch_address);
|
||||
|
||||
// don't care about success or failure
|
||||
m_watch_address_set.insert(watch_address);
|
||||
|
|
|
|||
|
|
@ -156,9 +156,6 @@ class Profiler : public SimObject, public Consumer
|
|||
|
||||
void sequencerRequests(int num) { m_sequencer_requests.add(num); }
|
||||
|
||||
void profileTransition(const std::string& component, NodeID version,
|
||||
Address addr, const std::string& state, const std::string& event,
|
||||
const std::string& next_state, const std::string& note);
|
||||
void profileMsgDelay(int virtualNetwork, int delayCycles);
|
||||
|
||||
void print(std::ostream& out) const;
|
||||
|
|
|
|||
|
|
@ -33,6 +33,8 @@
|
|||
#ifndef __MEM_RUBY_SLICC_INTERFACE_RUBYSLICCUTIL_HH__
|
||||
#define __MEM_RUBY_SLICC_INTERFACE_RUBYSLICCUTIL_HH__
|
||||
|
||||
#include <cassert>
|
||||
|
||||
#include "mem/protocol/AccessType.hh"
|
||||
#include "mem/protocol/CacheMsg.hh"
|
||||
#include "mem/protocol/CacheRequestType.hh"
|
||||
|
|
@ -134,7 +136,7 @@ getTimePlusInt(Time addend1, int addend2)
|
|||
inline Time
|
||||
getTimeMinusTime(Time t1, Time t2)
|
||||
{
|
||||
ASSERT(t1 >= t2);
|
||||
assert(t1 >= t2);
|
||||
return t1 - t2;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -26,14 +26,17 @@
|
|||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include <cassert>
|
||||
#include <cstdio>
|
||||
#include <map>
|
||||
|
||||
#include "base/trace.hh"
|
||||
#include "mem/ruby/common/Global.hh"
|
||||
#include "mem/ruby/storebuffer/storebuffer.hh"
|
||||
|
||||
using namespace std;
|
||||
|
||||
#define SYSTEM_EXIT ASSERT(0)
|
||||
#define SYSTEM_EXIT assert(0)
|
||||
|
||||
// global map of request id_s to map them back to storebuffer pointers
|
||||
map<uint64_t, StoreBuffer *> request_map;
|
||||
|
|
@ -58,7 +61,7 @@ StoreBuffer::StoreBuffer(uint32 id, uint32 block_bits, int storebuffer_size)
|
|||
sprintf(port_name, "%s%d", name, id);
|
||||
m_port = libruby_get_port(port_name, hit);
|
||||
m_hit_callback = NULL;
|
||||
ASSERT(storebuffer_size >= 0);
|
||||
assert(storebuffer_size >= 0);
|
||||
m_storebuffer_size = storebuffer_size;
|
||||
m_id = id;
|
||||
m_block_size = 1 << block_bits;
|
||||
|
|
@ -188,7 +191,7 @@ StoreBuffer::checkForLoadHit(RubyRequest request)
|
|||
// if any matching entry is found, determine if all the
|
||||
// requested bytes have been matched
|
||||
if (found) {
|
||||
ASSERT(m_buffer_size > 0);
|
||||
assert(m_buffer_size > 0);
|
||||
int unmatched_bytes = 0;
|
||||
for (int i = physical_address%64; i < len; i++) {
|
||||
unmatched_bytes = unmatched_bytes + data[i];
|
||||
|
|
@ -221,7 +224,7 @@ StoreBuffer::returnMatchedData(RubyRequest request)
|
|||
physical_address_t physical_address = request.paddr;
|
||||
int len = request.len;
|
||||
|
||||
ASSERT(checkForLoadHit(request) != NO_MATCH);
|
||||
assert(checkForLoadHit(request) != NO_MATCH);
|
||||
physical_address_t lineaddr = physical_address & m_block_mask;
|
||||
bool found = false;
|
||||
deque<SBEntry>::iterator satisfying_store;
|
||||
|
|
@ -285,7 +288,7 @@ StoreBuffer::complete(uint64_t id)
|
|||
return;
|
||||
}
|
||||
|
||||
ASSERT(outstanding_requests.find(id) != outstanding_requests.end());
|
||||
assert(outstanding_requests.find(id) != outstanding_requests.end());
|
||||
physical_address_t physical_address =
|
||||
outstanding_requests.find(id)->second.paddr;
|
||||
RubyRequestType type = outstanding_requests.find(id)->second.type;
|
||||
|
|
@ -306,7 +309,7 @@ StoreBuffer::complete(uint64_t id)
|
|||
from_buffer.m_request.type == type) {
|
||||
buffer.pop_back();
|
||||
m_buffer_size--;
|
||||
ASSERT(m_buffer_size >= 0);
|
||||
assert(m_buffer_size >= 0);
|
||||
|
||||
// schedule the next request
|
||||
if (m_buffer_size > 0) {
|
||||
|
|
|
|||
|
|
@ -40,7 +40,6 @@ class RubySystem(SimObject):
|
|||
"default cache block size; must be a power of two");
|
||||
mem_size = Param.MemorySize("total memory size of the system");
|
||||
network = Param.RubyNetwork("")
|
||||
debug = Param.RubyDebug("the default debug object")
|
||||
profiler = Param.RubyProfiler("");
|
||||
tracer = Param.RubyTracer("");
|
||||
stats_filename = Param.String("ruby.stats",
|
||||
|
|
|
|||
|
|
@ -485,19 +485,10 @@ Sequencer::hitCallback(SequencerRequest* srequest,
|
|||
g_eventQueue_ptr->getTime());
|
||||
}
|
||||
|
||||
if (Debug::getProtocolTrace()) {
|
||||
if (success) {
|
||||
g_system_ptr->getProfiler()->
|
||||
profileTransition("Seq", m_version,
|
||||
Address(ruby_request.paddr), "", "Done", "",
|
||||
csprintf("%d cycles", miss_latency));
|
||||
} else {
|
||||
g_system_ptr->getProfiler()->
|
||||
profileTransition("Seq", m_version,
|
||||
Address(ruby_request.paddr), "", "SC_Failed", "",
|
||||
csprintf("%d cycles", miss_latency));
|
||||
}
|
||||
}
|
||||
DPRINTFR(ProtocolTrace, "%7s %3s %10s%20s %6s>%-6s %s %d cycles\n",
|
||||
g_eventQueue_ptr->getTime(), m_version, "Seq",
|
||||
success ? "Done" : "SC_Failed", "", "",
|
||||
Address(ruby_request.paddr), miss_latency);
|
||||
}
|
||||
#if 0
|
||||
if (request.getPrefetch() == PrefetchBit_Yes) {
|
||||
|
|
@ -658,18 +649,9 @@ Sequencer::issueRequest(const RubyRequest& request)
|
|||
Address(request.pc), amtype, request.len, PrefetchBit_No,
|
||||
request.proc_id);
|
||||
|
||||
if (Debug::getProtocolTrace()) {
|
||||
g_system_ptr->getProfiler()->
|
||||
profileTransition("Seq", m_version, Address(request.paddr),
|
||||
"", "Begin", "",
|
||||
RubyRequestType_to_string(request.type));
|
||||
}
|
||||
|
||||
if (g_system_ptr->getTracer()->traceEnabled()) {
|
||||
g_system_ptr->getTracer()->
|
||||
traceRequest(this, line_addr, Address(request.pc),
|
||||
request.type, g_eventQueue_ptr->getTime());
|
||||
}
|
||||
DPRINTFR(ProtocolTrace, "%7s %3s %10s%20s %6s>%-6s %s %s\n",
|
||||
g_eventQueue_ptr->getTime(), m_version, "Seq", "Begin", "", "",
|
||||
Address(request.paddr), RubyRequestType_to_string(request.type));
|
||||
|
||||
Time latency = 0; // initialzed to an null value
|
||||
|
||||
|
|
|
|||
|
|
@ -75,7 +75,6 @@ RubySystem::RubySystem(const Params *p)
|
|||
}
|
||||
|
||||
m_network_ptr = p->network;
|
||||
g_debug_ptr = p->debug;
|
||||
m_profiler_ptr = p->profiler;
|
||||
m_tracer_ptr = p->tracer;
|
||||
|
||||
|
|
|
|||
|
|
@ -27,10 +27,7 @@
|
|||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
/*
|
||||
* $Id$
|
||||
*
|
||||
*/
|
||||
#include <cassert>
|
||||
|
||||
#include "base/misc.hh"
|
||||
#include "mem/ruby/common/Global.hh"
|
||||
|
|
@ -127,7 +124,7 @@ void DeterministicDriver::wakeup() {
|
|||
|
||||
void DeterministicDriver::hitCallback(int64_t request_id)
|
||||
{
|
||||
ASSERT(requests.find(request_id) != requests.end());
|
||||
assert(requests.find(request_id) != requests.end());
|
||||
int proc = requests[request_id].first;
|
||||
Address address = requests[request_id].second;
|
||||
|
||||
|
|
@ -177,7 +174,7 @@ bool DeterministicDriver::isAddrReady(NodeID node, vector<NodeID> addr_vector, A
|
|||
{
|
||||
int addr_number = addr.getAddress()/DATA_BLOCK_BYTES;
|
||||
|
||||
ASSERT ((addr_number >= 0) && (addr_number < addr_vector.size()));
|
||||
assert((addr_number >= 0) && (addr_number < addr_vector.size()));
|
||||
|
||||
if (((addr_vector[addr_number]+1)%m_num_procs == node) &&
|
||||
(m_loads_completed+m_stores_completed >= m_numCompletionsPerNode*node) && // is this node next
|
||||
|
|
@ -226,7 +223,7 @@ Address DeterministicDriver::getNextAddr(NodeID node, vector<NodeID> addr_vector
|
|||
Address addr;
|
||||
|
||||
// should only be called if we know a addr is ready for the node
|
||||
ASSERT(isAddrReady(node, addr_vector));
|
||||
assert(isAddrReady(node, addr_vector));
|
||||
|
||||
for (int addr_number=0; addr_number<addr_vector.size(); addr_number++) {
|
||||
|
||||
|
|
|
|||
|
|
@ -27,10 +27,8 @@
|
|||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
/*
|
||||
* $Id$
|
||||
*
|
||||
*/
|
||||
#include <cassert>
|
||||
|
||||
#include "mem/ruby/common/Global.hh"
|
||||
#include "mem/ruby/tester/Tester_Globals.hh"
|
||||
#include "mem/ruby/tester/RaceyDriver.hh"
|
||||
|
|
@ -77,7 +75,7 @@ void RaceyDriver::go() {
|
|||
|
||||
void RaceyDriver::hitCallback(int64_t request_id)
|
||||
{
|
||||
ASSERT(requests.find(request_id) != requests.end());
|
||||
assert(requests.find(request_id) != requests.end());
|
||||
int proc = requests[request_id].first;
|
||||
Address address = requests[request_id].second.address;
|
||||
uint8_t * data = new uint8_t[4];
|
||||
|
|
|
|||
|
|
@ -30,6 +30,8 @@
|
|||
* Description: see RaceyPseudoThread.h
|
||||
*/
|
||||
|
||||
#include <cassert>
|
||||
|
||||
#include "mem/ruby/tester/RaceyPseudoThread.hh"
|
||||
#include "mem/ruby/tester/RaceyDriver.hh"
|
||||
#include "gzstream.hh"
|
||||
|
|
@ -221,7 +223,7 @@ void RaceyPseudoThread::load_sig(unsigned index) {
|
|||
// pc is zero, problem?
|
||||
int64_t request_id = libruby_issue_request(libruby_get_port_by_name(port_name), RubyRequest(sig(index), read_data, 4, 0, RubyRequestType_LD, RubyAccessMode_User));
|
||||
|
||||
ASSERT(m_driver.requests.find(request_id) == m_driver.requests.end());
|
||||
assert(m_driver.requests.find(request_id) == m_driver.requests.end());
|
||||
|
||||
struct address_data request_data;
|
||||
request_data.address = Address(sig(index));
|
||||
|
|
@ -248,7 +250,7 @@ void RaceyPseudoThread::load_m(unsigned index) {
|
|||
// pc is zero, problem?
|
||||
int64_t request_id = libruby_issue_request(libruby_get_port_by_name(port_name), RubyRequest(m(index), read_data, 4, 0, RubyRequestType_LD, RubyAccessMode_User));
|
||||
|
||||
ASSERT(m_driver.requests.find(request_id) == m_driver.requests.end());
|
||||
assert(m_driver.requests.find(request_id) == m_driver.requests.end());
|
||||
|
||||
struct address_data request_data;
|
||||
request_data.address = Address(m(index));
|
||||
|
|
@ -279,7 +281,7 @@ void RaceyPseudoThread::store_sig(unsigned index, unsigned value) {
|
|||
// pc is zero, problem?
|
||||
int64_t request_id = libruby_issue_request(libruby_get_port_by_name(port_name), RubyRequest(sig(index), write_data, 4, 0, RubyRequestType_ST, RubyAccessMode_User));
|
||||
|
||||
ASSERT(m_driver.requests.find(request_id) == m_driver.requests.end());
|
||||
assert(m_driver.requests.find(request_id) == m_driver.requests.end());
|
||||
|
||||
struct address_data request_data;
|
||||
request_data.address = Address(sig(index));
|
||||
|
|
@ -308,7 +310,7 @@ void RaceyPseudoThread::store_m(unsigned index, unsigned value) {
|
|||
// pc is zero, problem?
|
||||
int64_t request_id = libruby_issue_request(libruby_get_port_by_name(port_name), RubyRequest(m(index), write_data, 4, 0, RubyRequestType_ST, RubyAccessMode_User));
|
||||
|
||||
ASSERT(m_driver.requests.find(request_id) == m_driver.requests.end());
|
||||
assert(m_driver.requests.find(request_id) == m_driver.requests.end());
|
||||
|
||||
struct address_data request_data;
|
||||
request_data.address = Address(m(index));
|
||||
|
|
|
|||
|
|
@ -365,8 +365,6 @@ static void usageInstructions()
|
|||
counter++;
|
||||
}
|
||||
|
||||
cerr << endl;
|
||||
g_debug_ptr->usageInstructions();
|
||||
cerr << endl;
|
||||
|
||||
exit(1);
|
||||
|
|
|
|||
|
|
@ -338,6 +338,7 @@ static int m_num_controllers;
|
|||
* Created by slicc definition of Module "${{self.short}}"
|
||||
*/
|
||||
|
||||
#include <cassert>
|
||||
#include <sstream>
|
||||
#include <string>
|
||||
|
||||
|
|
@ -760,6 +761,8 @@ $c_ident::${{action.ident}}(const Address& addr)
|
|||
// Auto generated C++ code started by $__file__:$__line__
|
||||
// ${ident}: ${{self.short}}
|
||||
|
||||
#include <cassert>
|
||||
|
||||
#include "base/misc.hh"
|
||||
#include "mem/ruby/common/Global.hh"
|
||||
#include "mem/ruby/slicc_interface/RubySlicc_includes.hh"
|
||||
|
|
@ -829,7 +832,10 @@ ${ident}_Controller::wakeup()
|
|||
// Auto generated C++ code started by $__file__:$__line__
|
||||
// ${ident}: ${{self.short}}
|
||||
|
||||
#include <cassert>
|
||||
|
||||
#include "base/misc.hh"
|
||||
#include "base/trace.hh"
|
||||
#include "mem/ruby/common/Global.hh"
|
||||
#include "mem/protocol/${ident}_Controller.hh"
|
||||
#include "mem/protocol/${ident}_State.hh"
|
||||
|
|
@ -863,36 +869,30 @@ ${ident}_Controller::doTransition(${ident}_Event event,
|
|||
DPRINTF(RubyGenerated, "next_state: %s\\n",
|
||||
${ident}_State_to_string(next_state));
|
||||
m_profiler.countTransition(state, event);
|
||||
if (Debug::getProtocolTrace()) {
|
||||
g_system_ptr->getProfiler()->profileTransition("${ident}",
|
||||
m_version, addr,
|
||||
${ident}_State_to_string(state),
|
||||
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),
|
||||
GET_TRANSITION_COMMENT());
|
||||
}
|
||||
addr, GET_TRANSITION_COMMENT());
|
||||
|
||||
CLEAR_TRANSITION_COMMENT();
|
||||
${ident}_setState(addr, next_state);
|
||||
|
||||
} else if (result == TransitionResult_ResourceStall) {
|
||||
if (Debug::getProtocolTrace()) {
|
||||
g_system_ptr->getProfiler()->profileTransition("${ident}",
|
||||
m_version, addr,
|
||||
${ident}_State_to_string(state),
|
||||
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),
|
||||
"Resource Stall");
|
||||
}
|
||||
addr, "Resource Stall");
|
||||
} else if (result == TransitionResult_ProtocolStall) {
|
||||
DPRINTF(RubyGenerated, "stalling\\n");
|
||||
if (Debug::getProtocolTrace()) {
|
||||
g_system_ptr->getProfiler()->profileTransition("${ident}",
|
||||
m_version, addr,
|
||||
${ident}_State_to_string(state),
|
||||
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),
|
||||
"Protocol Stall");
|
||||
}
|
||||
addr, "Protocol Stall");
|
||||
}
|
||||
|
||||
return result;
|
||||
|
|
@ -993,6 +993,7 @@ if (!%s.areNSlotsAvailable(%s))
|
|||
#ifndef __${ident}_PROFILE_DUMPER_HH__
|
||||
#define __${ident}_PROFILE_DUMPER_HH__
|
||||
|
||||
#include <cassert>
|
||||
#include <iostream>
|
||||
#include <vector>
|
||||
|
||||
|
|
@ -1088,6 +1089,7 @@ ${ident}_ProfileDumper::dumpStats(std::ostream& out) const
|
|||
#ifndef __${ident}_PROFILER_HH__
|
||||
#define __${ident}_PROFILER_HH__
|
||||
|
||||
#include <cassert>
|
||||
#include <iostream>
|
||||
|
||||
#include "mem/ruby/common/Global.hh"
|
||||
|
|
@ -1125,6 +1127,8 @@ class ${ident}_Profiler
|
|||
// Auto generated C++ code started by $__file__:$__line__
|
||||
// ${ident}: ${{self.short}}
|
||||
|
||||
#include <cassert>
|
||||
|
||||
#include "mem/protocol/${ident}_Profiler.hh"
|
||||
|
||||
${ident}_Profiler::${ident}_Profiler()
|
||||
|
|
|
|||
|
|
@ -508,6 +508,7 @@ std::ostream& operator<<(std::ostream& out, const ${{self.c_ident}}& obj);
|
|||
* Auto generated C++ code started by $__file__:$__line__
|
||||
*/
|
||||
|
||||
#include <cassert>
|
||||
#include <iostream>
|
||||
#include <string>
|
||||
|
||||
|
|
|
|||
Loading…
Reference in a new issue