* Authors: Niket Agarwal
*/
-#include "mem/ruby/buffers/MessageBuffer.hh"
-#include "mem/ruby/network/BasicLink.hh"
-#include "mem/ruby/network/Topology.hh"
#include "mem/ruby/network/garnet/BaseGarnetNetwork.hh"
+#include "mem/ruby/network/MessageBuffer.hh"
using namespace std;
if (m_enable_fault_model)
fault_model = p->fault_model;
- m_ruby_start = 0;
-
// Currently Garnet only supports uniform bandwidth for all
// links and network interfaces.
- for (std::vector<BasicExtLink*>::const_iterator i =
- m_topology_ptr->params()->ext_links.begin();
- i != m_topology_ptr->params()->ext_links.end(); ++i) {
+ for (std::vector<BasicExtLink*>::const_iterator i = p->ext_links.begin();
+ i != p->ext_links.end(); ++i) {
BasicExtLink* ext_link = (*i);
if (ext_link->params()->bandwidth_factor != m_ni_flit_size) {
fatal("Garnet only supports uniform bw across all links and NIs\n");
}
}
- for (std::vector<BasicIntLink*>::const_iterator i =
- m_topology_ptr->params()->int_links.begin();
- i != m_topology_ptr->params()->int_links.end(); ++i) {
+ for (std::vector<BasicIntLink*>::const_iterator i = p->int_links.begin();
+ i != p->int_links.end(); ++i) {
BasicIntLink* int_link = (*i);
if (int_link->params()->bandwidth_factor != m_ni_flit_size) {
fatal("Garnet only supports uniform bw across all links and NIs\n");
}
}
-
- // Allocate to and from queues
-
- // Queues that are getting messages from protocol
- m_toNetQueues.resize(m_nodes);
-
- // Queues that are feeding the protocol
- m_fromNetQueues.resize(m_nodes);
-
- m_in_use.resize(m_virtual_networks);
- m_ordered.resize(m_virtual_networks);
- m_flits_received.resize(m_virtual_networks);
- m_flits_injected.resize(m_virtual_networks);
- m_network_latency.resize(m_virtual_networks);
- m_queueing_latency.resize(m_virtual_networks);
- for (int i = 0; i < m_virtual_networks; i++) {
- m_in_use[i] = false;
- m_ordered[i] = false;
- m_flits_received[i] = 0;
- m_flits_injected[i] = 0;
- m_network_latency[i] = 0.0;
- m_queueing_latency[i] = 0.0;
- }
-
- for (int node = 0; node < m_nodes; node++) {
- // Setting number of virtual message buffers per Network Queue
- m_toNetQueues[node].resize(m_virtual_networks);
- m_fromNetQueues[node].resize(m_virtual_networks);
-
- // Instantiating the Message Buffers that
- // interact with the coherence protocol
- for (int j = 0; j < m_virtual_networks; j++) {
- m_toNetQueues[node][j] = new MessageBuffer();
- m_fromNetQueues[node][j] = new MessageBuffer();
- }
- }
}
void
Network::init();
}
-MessageBuffer*
-BaseGarnetNetwork::getToNetQueue(NodeID id, bool ordered, int network_num,
- string vnet_type)
+void
+BaseGarnetNetwork::setToNetQueue(NodeID id, bool ordered, int network_num,
+ string vnet_type, MessageBuffer *b)
{
checkNetworkAllocation(id, ordered, network_num, vnet_type);
- return m_toNetQueues[id][network_num];
+ m_toNetQueues[id][network_num] = b;
}
-MessageBuffer*
-BaseGarnetNetwork::getFromNetQueue(NodeID id, bool ordered, int network_num,
- string vnet_type)
+void
+BaseGarnetNetwork::setFromNetQueue(NodeID id, bool ordered, int network_num,
+ string vnet_type, MessageBuffer *b)
{
checkNetworkAllocation(id, ordered, network_num, vnet_type);
- return m_fromNetQueues[id][network_num];
+ m_fromNetQueues[id][network_num] = b;
}
void
-BaseGarnetNetwork::clearStats()
+BaseGarnetNetwork::regStats()
{
- m_ruby_start = g_eventQueue_ptr->getTime();
-}
+ m_flits_received
+ .init(m_virtual_networks)
+ .name(name() + ".flits_received")
+ .flags(Stats::pdf | Stats::total | Stats::nozero | Stats::oneline)
+ ;
+
+ m_flits_injected
+ .init(m_virtual_networks)
+ .name(name() + ".flits_injected")
+ .flags(Stats::pdf | Stats::total | Stats::nozero | Stats::oneline)
+ ;
+
+ m_network_latency
+ .init(m_virtual_networks)
+ .name(name() + ".network_latency")
+ .flags(Stats::oneline)
+ ;
+
+ m_queueing_latency
+ .init(m_virtual_networks)
+ .name(name() + ".queueing_latency")
+ .flags(Stats::oneline)
+ ;
-Time
-BaseGarnetNetwork::getRubyStartTime()
-{
- return m_ruby_start;
-}
+ for (int i = 0; i < m_virtual_networks; i++) {
+ m_flits_received.subname(i, csprintf("vnet-%i", i));
+ m_flits_injected.subname(i, csprintf("vnet-%i", i));
+ m_network_latency.subname(i, csprintf("vnet-%i", i));
+ m_queueing_latency.subname(i, csprintf("vnet-%i", i));
+ }
-void
-BaseGarnetNetwork::printStats(ostream& out) const
-{
- out << endl;
- out << "Network Stats" << endl;
- out << "-------------" << endl;
- out << endl;
- printPerformanceStats(out);
- printLinkStats(out);
- printPowerStats(out);
- m_topology_ptr->printStats(out);
-}
+ m_avg_vnet_latency
+ .name(name() + ".average_vnet_latency")
+ .flags(Stats::oneline);
+ m_avg_vnet_latency = m_network_latency / m_flits_received;
-void
-BaseGarnetNetwork::printPerformanceStats(ostream& out) const
-{
- int total_flits_injected = 0;
- int total_flits_received = 0;
- int total_network_latency = 0.0;
- int total_queueing_latency = 0.0;
+ m_avg_vqueue_latency
+ .name(name() + ".average_vqueue_latency")
+ .flags(Stats::oneline);
+ m_avg_vqueue_latency = m_queueing_latency / m_flits_received;
- for (int i = 0; i < m_virtual_networks; i++) {
- if (!m_in_use[i])
- continue;
-
- out << "[Vnet " << i << "]: flits injected = "
- << m_flits_injected[i] << endl;
- out << "[Vnet " << i << "]: flits received = "
- << m_flits_received[i] << endl;
- out << "[Vnet " << i << "]: average network latency = "
- << ((double) m_network_latency[i] / (double) m_flits_received[i])
- << endl;
- out << "[Vnet " << i << "]: average queueing (at source NI) latency = "
- << ((double) m_queueing_latency[i] / (double) m_flits_received[i])
- << endl;
-
- out << endl;
- total_flits_injected += m_flits_injected[i];
- total_flits_received += m_flits_received[i];
- total_network_latency += m_network_latency[i];
- total_queueing_latency += m_queueing_latency[i];
- }
- out << "Total flits injected = " << total_flits_injected << endl;
- out << "Total flits received = " << total_flits_received << endl;
- out << "Average network latency = "
- << ((double) total_network_latency/ (double) total_flits_received) << endl;
- out << "Average queueing (at source NI) latency = "
- << ((double) total_queueing_latency/ (double) total_flits_received) << endl;
- out << "Average latency = "
- << ((double) (total_queueing_latency + total_network_latency) /
- (double) total_flits_received)<< endl;
- out << "-------------" << endl;
- out << endl;
-}
+ m_avg_network_latency.name(name() + ".average_network_latency");
+ m_avg_network_latency = sum(m_network_latency) / sum(m_flits_received);
+
+ m_avg_queueing_latency.name(name() + ".average_queueing_latency");
+ m_avg_queueing_latency = sum(m_queueing_latency) / sum(m_flits_received);
+ m_avg_latency.name(name() + ".average_latency");
+ m_avg_latency = m_avg_network_latency + m_avg_queueing_latency;
+}
projects / gem5.git / blobdiff