src/mem/ruby/network/garnet/BaseGarnetNetwork.cc

   1 /*
   2  * Copyright (c) 2008 Princeton University
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions are
   7  * met: redistributions of source code must retain the above copyright
   8  * notice, this list of conditions and the following disclaimer;
   9  * redistributions in binary form must reproduce the above copyright
  10  * notice, this list of conditions and the following disclaimer in the
  11  * documentation and/or other materials provided with the distribution;
  12  * neither the name of the copyright holders nor the names of its
  13  * contributors may be used to endorse or promote products derived from
  14  * this software without specific prior written permission.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  17  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  18  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  19  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  20  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  21  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  22  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  26  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  *
  28  * Authors: Niket Agarwal
  29  */
  30
  31 #include "mem/ruby/buffers/MessageBuffer.hh"
  32 #include "mem/ruby/network/BasicLink.hh"
  33 #include "mem/ruby/network/Topology.hh"
  34 #include "mem/ruby/network/garnet/BaseGarnetNetwork.hh"
  35
  36 using namespace std;
  37
  38 BaseGarnetNetwork::BaseGarnetNetwork(const Params *p)
  39     : Network(p)
  40 {
  41     m_ni_flit_size = p->ni_flit_size;
  42     m_vcs_per_vnet = p->vcs_per_vnet;
  43     m_enable_fault_model = p->enable_fault_model;
  44     if (m_enable_fault_model)
  45         fault_model = p->fault_model;
  46
  47     m_ruby_start = 0;
  48
  49     // Currently Garnet only supports uniform bandwidth for all
  50     // links and network interfaces.
  51     for (std::vector<BasicExtLink*>::const_iterator i =
  52              m_topology_ptr->params()->ext_links.begin();
  53          i != m_topology_ptr->params()->ext_links.end(); ++i) {
  54         BasicExtLink* ext_link = (*i);
  55         if (ext_link->params()->bandwidth_factor != m_ni_flit_size) {
  56             fatal("Garnet only supports uniform bw across all links and NIs\n");
  57         }
  58     }
  59     for (std::vector<BasicIntLink*>::const_iterator i =
  60              m_topology_ptr->params()->int_links.begin();
  61          i != m_topology_ptr->params()->int_links.end(); ++i) {
  62         BasicIntLink* int_link = (*i);
  63         if (int_link->params()->bandwidth_factor != m_ni_flit_size) {
  64             fatal("Garnet only supports uniform bw across all links and NIs\n");
  65         }
  66     }
  67
  68     // Allocate to and from queues
  69
  70     // Queues that are getting messages from protocol
  71     m_toNetQueues.resize(m_nodes);
  72
  73     // Queues that are feeding the protocol
  74     m_fromNetQueues.resize(m_nodes);
  75
  76     m_in_use.resize(m_virtual_networks);
  77     m_ordered.resize(m_virtual_networks);
  78     m_flits_received.resize(m_virtual_networks);
  79     m_flits_injected.resize(m_virtual_networks);
  80     m_network_latency.resize(m_virtual_networks);
  81     m_queueing_latency.resize(m_virtual_networks);
  82     for (int i = 0; i < m_virtual_networks; i++) {
  83         m_in_use[i] = false;
  84         m_ordered[i] = false;
  85         m_flits_received[i] = 0;
  86         m_flits_injected[i] = 0;
  87         m_network_latency[i] = 0.0;
  88         m_queueing_latency[i] = 0.0;
  89     }
  90
  91     for (int node = 0; node < m_nodes; node++) {
  92         // Setting number of virtual message buffers per Network Queue
  93         m_toNetQueues[node].resize(m_virtual_networks);
  94         m_fromNetQueues[node].resize(m_virtual_networks);
  95
  96         // Instantiating the Message Buffers that
  97         // interact with the coherence protocol
  98         for (int j = 0; j < m_virtual_networks; j++) {
  99             m_toNetQueues[node][j] = new MessageBuffer();
 100             m_fromNetQueues[node][j] = new MessageBuffer();
 101         }
 102     }
 103 }
 104
 105 void
 106 BaseGarnetNetwork::init()
 107 {
 108     Network::init();
 109 }
 110
 111 MessageBuffer*
 112 BaseGarnetNetwork::getToNetQueue(NodeID id, bool ordered, int network_num,
 113                                  string vnet_type)
 114 {
 115     checkNetworkAllocation(id, ordered, network_num, vnet_type);
 116     return m_toNetQueues[id][network_num];
 117 }
 118
 119 MessageBuffer*
 120 BaseGarnetNetwork::getFromNetQueue(NodeID id, bool ordered, int network_num,
 121                                    string vnet_type)
 122 {
 123     checkNetworkAllocation(id, ordered, network_num, vnet_type);
 124     return m_fromNetQueues[id][network_num];
 125 }
 126
 127 void
 128 BaseGarnetNetwork::clearStats()
 129 {
 130     m_ruby_start = curCycle();
 131 }
 132
 133 Time
 134 BaseGarnetNetwork::getRubyStartTime()
 135 {
 136     return m_ruby_start;
 137 }
 138
 139 void
 140 BaseGarnetNetwork::printStats(ostream& out) const
 141 {
 142     out << endl;
 143     out << "Network Stats" << endl;
 144     out << "-------------" << endl;
 145     out << endl;
 146     printPerformanceStats(out);
 147     printLinkStats(out);
 148     printPowerStats(out);
 149     m_topology_ptr->printStats(out);
 150 }
 151
 152 void
 153 BaseGarnetNetwork::printPerformanceStats(ostream& out) const
 154 {
 155     int total_flits_injected = 0;
 156     int total_flits_received = 0;
 157     int total_network_latency = 0.0;
 158     int total_queueing_latency = 0.0;
 159
 160     for (int i = 0; i < m_virtual_networks; i++) {
 161         if (!m_in_use[i])
 162             continue;
 163
 164         out << "[Vnet " << i << "]: flits injected = "
 165             << m_flits_injected[i] << endl;
 166         out << "[Vnet " << i << "]: flits received = "
 167             << m_flits_received[i] << endl;
 168         out << "[Vnet " << i << "]: average network latency = "
 169             << ((double) m_network_latency[i] / (double) m_flits_received[i])
 170             << endl;
 171         out << "[Vnet " << i << "]: average queueing (at source NI) latency = "
 172             << ((double) m_queueing_latency[i] / (double) m_flits_received[i])
 173             << endl;
 174
 175         out << endl;
 176         total_flits_injected += m_flits_injected[i];
 177         total_flits_received += m_flits_received[i];
 178         total_network_latency += m_network_latency[i];
 179         total_queueing_latency += m_queueing_latency[i];
 180     }
 181     out << "Total flits injected = " << total_flits_injected << endl;
 182     out << "Total flits received = " << total_flits_received << endl;
 183     out << "Average network latency = "
 184         << ((double) total_network_latency/ (double) total_flits_received) << endl;
 185     out << "Average queueing (at source NI) latency = "
 186         << ((double) total_queueing_latency/ (double) total_flits_received) << endl;
 187     out << "Average latency = "
 188         << ((double)  (total_queueing_latency + total_network_latency) /
 189             (double) total_flits_received)<< endl;
 190     out << "-------------" << endl;
 191     out << endl;
 192 }
 193