fault_model = p->fault_model;
m_ruby_start = 0;
- m_flits_received = 0;
- m_flits_injected = 0;
- m_network_latency = 0.0;
- m_queueing_latency = 0.0;
// Currently Garnet only supports uniform bandwidth for all
// links and network interfaces.
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++) {
{
Network::init();
}
+
+MessageBuffer*
+BaseGarnetNetwork::getToNetQueue(NodeID id, bool ordered, int network_num,
+ string vnet_type)
+{
+ checkNetworkAllocation(id, ordered, network_num, vnet_type);
+ return m_toNetQueues[id][network_num];
+}
+
+MessageBuffer*
+BaseGarnetNetwork::getFromNetQueue(NodeID id, bool ordered, int network_num,
+ string vnet_type)
+{
+ checkNetworkAllocation(id, ordered, network_num, vnet_type);
+ return m_fromNetQueues[id][network_num];
+}
+
+void
+BaseGarnetNetwork::clearStats()
+{
+ m_ruby_start = g_eventQueue_ptr->getTime();
+}
+
+Time
+BaseGarnetNetwork::getRubyStartTime()
+{
+ return m_ruby_start;
+}
+
+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);
+}
+
+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;
+
+ 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;
+}
+
bool isFaultModelEnabled() {return m_enable_fault_model;}
FaultModel* fault_model;
+ void increment_injected_flits(int vnet) { m_flits_injected[vnet]++; }
+ void increment_received_flits(int vnet) { m_flits_received[vnet]++; }
+
+ void
+ increment_network_latency(Time latency, int vnet)
+ {
+ m_network_latency[vnet] += latency;
+ }
+
+ void
+ increment_queueing_latency(Time latency, int vnet)
+ {
+ m_queueing_latency[vnet] += latency;
+ }
+
+ // returns the queue requested for the given component
+ MessageBuffer* getToNetQueue(NodeID id, bool ordered, int network_num,
+ std::string vnet_type);
+ MessageBuffer* getFromNetQueue(NodeID id, bool ordered, int network_num,
+ std::string vnet_type);
+
+
+ bool isVNetOrdered(int vnet) { return m_ordered[vnet]; }
+ bool validVirtualNetwork(int vnet) { return m_in_use[vnet]; }
+ virtual void checkNetworkAllocation(NodeID id, bool ordered,
+ int network_num, std::string vnet_type) = 0;
+
+ Time getRubyStartTime();
+ void clearStats();
+ void printStats(std::ostream& out) const;
+ void printPerformanceStats(std::ostream& out) const;
+ virtual void printLinkStats(std::ostream& out) const = 0;
+ virtual void printPowerStats(std::ostream& out) const = 0;
+
protected:
int m_ni_flit_size;
int m_vcs_per_vnet;
bool m_enable_fault_model;
- int m_flits_received;
- int m_flits_injected;
- double m_network_latency;
- double m_queueing_latency;
+ std::vector<int> m_flits_received;
+ std::vector<int> m_flits_injected;
+ std::vector<double> m_network_latency;
+ std::vector<double> m_queueing_latency;
std::vector<bool> m_in_use;
std::vector<bool> m_ordered;
m_vnet_type[network_num] = CTRL_VNET_; // carries only ctrl packets
}
-MessageBuffer*
-GarnetNetwork_d::getToNetQueue(NodeID id, bool ordered, int network_num,
- string vnet_type)
-{
- checkNetworkAllocation(id, ordered, network_num, vnet_type);
- return m_toNetQueues[id][network_num];
-}
-
-MessageBuffer*
-GarnetNetwork_d::getFromNetQueue(NodeID id, bool ordered, int network_num,
- string vnet_type)
-{
- checkNetworkAllocation(id, ordered, network_num, vnet_type);
- return m_fromNetQueues[id][network_num];
-}
-
void
-GarnetNetwork_d::clearStats()
-{
- m_ruby_start = g_eventQueue_ptr->getTime();
-}
-
-Time
-GarnetNetwork_d::getRubyStartTime()
-{
- return m_ruby_start;
-}
-
-void
-GarnetNetwork_d::printStats(ostream& out) const
+GarnetNetwork_d::printLinkStats(ostream& out) const
{
double average_link_utilization = 0;
vector<double> average_vc_load;
average_vc_load.resize(m_virtual_networks*m_vcs_per_vnet);
- for (int i = 0; i < m_virtual_networks*m_vcs_per_vnet; i++)
- {
+ for (int i = 0; i < m_virtual_networks*m_vcs_per_vnet; i++) {
average_vc_load[i] = 0;
}
- out << endl;
- out << "Network Stats" << endl;
- out << "-------------" << endl;
out << endl;
for (int i = 0; i < m_link_ptr_vector.size(); i++) {
average_link_utilization +=
<< " flits/cycle " << endl;
}
out << "-------------" << endl;
+ out << endl;
+}
- out << "Total flits injected = " << m_flits_injected << endl;
- out << "Total flits received = " << m_flits_received << endl;
- out << "Average network latency = "
- << ((double) m_network_latency/ (double) m_flits_received)<< endl;
- out << "Average queueing (at source NI) latency = "
- << ((double) m_queueing_latency/ (double) m_flits_received)<< endl;
- out << "Average latency = "
- << ((double) (m_queueing_latency + m_network_latency) /
- (double) m_flits_received)<< endl;
+void
+GarnetNetwork_d::printPowerStats(ostream& out) const
+{
+ out << "Network Power" << endl;
out << "-------------" << endl;
-
double m_total_link_power = 0.0;
double m_dynamic_link_power = 0.0;
double m_static_link_power = 0.0;
out << "Router Static Power = " << m_static_router_power << " W" << endl;
out << "Total Router Power = " << m_total_router_power << " W " <<endl;
out << "-------------" << endl;
- m_topology_ptr->printStats(out);
+ out << endl;
}
void
out << endl;
out << "Network Configuration" << endl;
out << "---------------------" << endl;
- out << "network: GarnetNetwork_d" << endl;
+ out << "network: Garnet Fixed Pipeline" << endl;
out << "topology: " << m_topology_ptr->getName() << endl;
out << endl;
int getBuffersPerDataVC() {return m_buffers_per_data_vc; }
int getBuffersPerCtrlVC() {return m_buffers_per_ctrl_vc; }
- // returns the queue requested for the given component
- MessageBuffer* getToNetQueue(NodeID id, bool ordered, int network_num,
- std::string vnet_type);
- MessageBuffer* getFromNetQueue(NodeID id, bool ordered, int network_num,
- std::string vnet_type);
-
- void clearStats();
- void printStats(std::ostream& out) const;
+ void printLinkStats(std::ostream& out) const;
+ void printPowerStats(std::ostream& out) const;
void printConfig(std::ostream& out) const;
void print(std::ostream& out) const;
return m_vnet_type[vnet];
}
-
- inline void increment_injected_flits() { m_flits_injected++; }
- inline void increment_received_flits() { m_flits_received++; }
-
- inline void
- increment_network_latency(Time latency)
- {
- m_network_latency += latency;
- }
-
- inline void
- increment_queueing_latency(Time latency)
- {
- m_queueing_latency += latency;
- }
-
- bool isVNetOrdered(int vnet) { return m_ordered[vnet]; }
- bool validVirtualNetwork(int vnet) { return m_in_use[vnet]; }
- Time getRubyStartTime();
-
void reset();
// Methods used by Topology to setup the network
}
for (int i = 0; i < num_flits; i++) {
- m_net_ptr->increment_injected_flits();
+ m_net_ptr->increment_injected_flits(vnet);
flit_d *fl = new flit_d(i, vc, vnet, num_flits, new_msg_ptr);
fl->set_delay(g_eventQueue_ptr->getTime() - msg_ptr->getTime());
m_ni_buffers[vc]->insert(fl);
creditQueue->insert(credit_flit);
g_eventQueue_ptr->scheduleEvent(m_ni_credit_link, 1);
- m_net_ptr->increment_received_flits();
+ int vnet = t_flit->get_vnet();
+ m_net_ptr->increment_received_flits(vnet);
int network_delay = g_eventQueue_ptr->getTime() -
t_flit->get_enqueue_time();
int queueing_delay = t_flit->get_delay();
- m_net_ptr->increment_network_latency(network_delay);
- m_net_ptr->increment_queueing_latency(queueing_delay);
+ m_net_ptr->increment_network_latency(network_delay, vnet);
+ m_net_ptr->increment_queueing_latency(queueing_delay, vnet);
delete t_flit;
}
void
GarnetNetwork::checkNetworkAllocation(NodeID id, bool ordered,
- int network_num)
+ int network_num, std::string vnet_type)
{
assert(id < m_nodes);
assert(network_num < m_virtual_networks);
m_in_use[network_num] = true;
}
-MessageBuffer*
-GarnetNetwork::getToNetQueue(NodeID id, bool ordered, int network_num,
- std::string vnet_type)
-{
- checkNetworkAllocation(id, ordered, network_num);
- return m_toNetQueues[id][network_num];
-}
-
-MessageBuffer*
-GarnetNetwork::getFromNetQueue(NodeID id, bool ordered, int network_num,
- std::string vnet_type)
-{
- checkNetworkAllocation(id, ordered, network_num);
- return m_fromNetQueues[id][network_num];
-}
-
-void
-GarnetNetwork::clearStats()
-{
- m_ruby_start = g_eventQueue_ptr->getTime();
-}
-
-Time
-GarnetNetwork::getRubyStartTime()
-{
- return m_ruby_start;
-}
-
void
-GarnetNetwork::printStats(ostream& out) const
+GarnetNetwork::printLinkStats(ostream& out) const
{
double average_link_utilization = 0;
vector<double> average_vc_load;
average_vc_load[i] = 0;
}
- out << endl;
- out << "Network Stats" << endl;
- out << "-------------" << endl;
out << endl;
for (int i = 0; i < m_link_ptr_vector.size(); i++) {
average_link_utilization +=
- m_link_ptr_vector[i]->getLinkUtilization();
+ (double(m_link_ptr_vector[i]->getLinkUtilization())) /
+ (double(g_eventQueue_ptr->getTime()-m_ruby_start));
+
vector<int> vc_load = m_link_ptr_vector[i]->getVcLoad();
for (int j = 0; j < vc_load.size(); j++) {
assert(vc_load.size() == m_vcs_per_vnet*m_virtual_networks);
}
average_link_utilization =
average_link_utilization/m_link_ptr_vector.size();
- out << "Average Link Utilization :: " << average_link_utilization <<
- " flits/cycle" <<endl;
+ out << "Average Link Utilization :: " << average_link_utilization
+ << " flits/cycle" << endl;
out << "-------------" << endl;
for (int i = 0; i < m_vcs_per_vnet*m_virtual_networks; i++) {
average_vc_load[i] = (double(average_vc_load[i]) /
(double(g_eventQueue_ptr->getTime()) - m_ruby_start));
- out << "Average VC Load [" << i << "] = " << average_vc_load[i] <<
- " flits/cycle" << endl;
+ out << "Average VC Load [" << i << "] = " << average_vc_load[i]
+ << " flits/cycle " << endl;
}
out << "-------------" << endl;
+ out << endl;
+}
- out << "Total flits injected = " << m_flits_injected << endl;
- out << "Total flits received = " << m_flits_received << endl;
- out << "Average network latency = "
- << ((double) m_network_latency/ (double) m_flits_received)<< endl;
- out << "Average queueing (at source NI) latency = "
- << ((double) m_queueing_latency/ (double) m_flits_received)<< endl;
- out << "Average latency = "
- << ((double) (m_queueing_latency + m_network_latency) /
- (double) m_flits_received)<< endl;
+void
+GarnetNetwork::printPowerStats(ostream& out) const
+{
+ out << "Network Power" << endl;
out << "-------------" << endl;
-
- m_topology_ptr->printStats(out);
+ out << "Orion does not work with flexible pipeline" << endl;
+ out << endl;
}
void
out << endl;
out << "Network Configuration" << endl;
out << "---------------------" << endl;
- out << "network: GARNET_NETWORK" << endl;
+ out << "network: Garnet Flexible Pipeline" << endl;
out << "topology: " << m_topology_ptr->getName() << endl;
out << endl;
out << "active, ";
if (m_ordered[i]) {
out << "ordered" << endl;
- } else {
+ } else {
out << "unordered" << endl;
}
- } else {
+ } else {
out << "inactive" << endl;
}
}
int getBufferSize() { return m_buffer_size; }
int getNumPipeStages() {return m_number_of_pipe_stages; }
- // returns the queue requested for the given component
- MessageBuffer* getToNetQueue(NodeID id, bool ordered, int network_num,
- std::string vnet_type);
- MessageBuffer* getFromNetQueue(NodeID id, bool ordered, int network_num,
- std::string vnet_type);
-
- void clearStats();
- void printStats(std::ostream& out) const;
- void printConfig(std::ostream& out) const;
- void print(std::ostream& out) const;
-
- inline void increment_injected_flits() { m_flits_injected++; }
- inline void increment_received_flits() { m_flits_received++; }
-
- inline void
- increment_network_latency(Time latency)
- {
- m_network_latency += latency;
- }
-
- inline void
- increment_queueing_latency(Time latency)
- {
- m_queueing_latency += latency;
- }
-
- bool isVNetOrdered(int vnet) { return m_ordered[vnet]; }
- bool validVirtualNetwork(int vnet) { return m_in_use[vnet]; }
-
- Time getRubyStartTime();
int getNumNodes(){ return m_nodes; }
void reset();
+ void printLinkStats(std::ostream& out) const;
+ void printPowerStats(std::ostream& out) const;
+ void printConfig(std::ostream& out) const;
+ void print(std::ostream& out) const;
+
// Methods used by Topology to setup the network
void makeOutLink(SwitchID src, NodeID dest, BasicLink* link,
LinkDirection direction,
bool isReconfiguration);
private:
- void checkNetworkAllocation(NodeID id, bool ordered, int network_num);
+ void checkNetworkAllocation(NodeID id, bool ordered, int network_num,
+ std::string vnet_type);
GarnetNetwork(const GarnetNetwork& obj);
GarnetNetwork& operator=(const GarnetNetwork& obj);
net_msg_ptr->getInternalDestination().removeNetDest(personal_dest);
}
for (int i = 0; i < num_flits; i++) {
- m_net_ptr->increment_injected_flits();
+ m_net_ptr->increment_injected_flits(vnet);
flit *fl = new flit(i, vc, vnet, num_flits, new_msg_ptr);
fl->set_delay(g_eventQueue_ptr->getTime() - msg_ptr->getTime());
m_ni_buffers[vc]->insert(fl);
inNetLink->release_vc_link(t_flit->get_vc(),
g_eventQueue_ptr->getTime() + 1);
}
- m_net_ptr->increment_received_flits();
+ int vnet = t_flit->get_vnet();
+ m_net_ptr->increment_received_flits(vnet);
int network_delay = g_eventQueue_ptr->getTime() -
t_flit->get_enqueue_time();
int queueing_delay = t_flit->get_delay();
- m_net_ptr->increment_network_latency(network_delay);
- m_net_ptr->increment_queueing_latency(queueing_delay);
+ m_net_ptr->increment_network_latency(network_delay, vnet);
+ m_net_ptr->increment_queueing_latency(queueing_delay, vnet);
delete t_flit;
}
}
projects / gem5.git / commitdiff