diff --git a/src/mem/ruby/network/simple/SimpleNetwork.hh b/src/mem/ruby/network/simple/SimpleNetwork.hh --- a/src/mem/ruby/network/simple/SimpleNetwork.hh +++ b/src/mem/ruby/network/simple/SimpleNetwork.hh @@ -59,13 +59,13 @@ bool isVNetOrdered(int vnet) const { return m_ordered[vnet]; } // Methods used by Topology to setup the network - void makeOutLink(SwitchID src, NodeID dest, BasicLink* link, + void makeOutLink(SimObject *src, SimObject *dest, BasicLink* link, LinkDirection direction, const NetDest& routing_table_entry); - void makeInLink(NodeID src, SwitchID dest, BasicLink* link, + void makeInLink(SimObject *src, SimObject *dest, BasicLink* link, LinkDirection direction, const NetDest& routing_table_entry); - void makeInternalLink(SwitchID src, SwitchID dest, BasicLink* link, + void makeInternalLink(SimObject *src, SimObject *dest, BasicLink* link, LinkDirection direction, const NetDest& routing_table_entry); diff --git a/src/mem/ruby/network/simple/SimpleNetwork.cc b/src/mem/ruby/network/simple/SimpleNetwork.cc --- a/src/mem/ruby/network/simple/SimpleNetwork.cc +++ b/src/mem/ruby/network/simple/SimpleNetwork.cc @@ -50,9 +50,9 @@ // record the routers for (vector::const_iterator i = p->routers.begin(); i != p->routers.end(); ++i) { - Switch* s = safe_cast(*i); - m_switches.push_back(s); - s->init_net_ptr(this); + Switch* swtch = safe_cast(*i); + m_switches.push_back(swtch); + swtch->init_net_ptr(this); } m_int_link_buffers = p->int_link_buffers; @@ -78,34 +78,33 @@ // From a switch to an endpoint node void -SimpleNetwork::makeOutLink(SwitchID src, NodeID dest, BasicLink* link, +SimpleNetwork::makeOutLink(SimObject *src, SimObject *dest, BasicLink* link, LinkDirection direction, const NetDest& routing_table_entry) { - assert(dest < m_nodes); - assert(src < m_switches.size()); - assert(m_switches[src] != NULL); - SimpleExtLink *simple_link = safe_cast(link); - - m_switches[src]->addOutPort(m_fromNetQueues[dest], routing_table_entry, - simple_link->m_latency, - simple_link->m_bw_multiplier); + Switch *src_switch = safe_cast(src); + AbstractController *dest_cont = safe_cast(dest); + src_switch->addOutPort(m_fromNetQueues[dest_cont], routing_table_entry, + simple_link->m_latency, + simple_link->m_bw_multiplier); } // From an endpoint node to a switch void -SimpleNetwork::makeInLink(NodeID src, SwitchID dest, BasicLink* link, +SimpleNetwork::makeInLink(SimObject *src, SimObject *dest, BasicLink* link, LinkDirection direction, const NetDest& routing_table_entry) { - assert(src < m_nodes); - m_switches[dest]->addInPort(m_toNetQueues[src]); + Switch *dest_switch = safe_cast(dest); + AbstractController *src_cont = safe_cast(src); + dest_switch->addInPort(m_toNetQueues[src_cont]); } // From a switch to a switch void -SimpleNetwork::makeInternalLink(SwitchID src, SwitchID dest, BasicLink* link, +SimpleNetwork::makeInternalLink(SimObject *src, SimObject *dest, + BasicLink* link, LinkDirection direction, const NetDest& routing_table_entry) { @@ -122,11 +121,13 @@ // Connect it to the two switches SimpleIntLink *simple_link = safe_cast(link); + Switch *src_switch = safe_cast(src); + Switch *dest_switch = safe_cast(dest); - m_switches[dest]->addInPort(queues); - m_switches[src]->addOutPort(queues, routing_table_entry, - simple_link->m_latency, - simple_link->m_bw_multiplier); + dest_switch->addInPort(queues); + src_switch->addOutPort(queues, routing_table_entry, + simple_link->m_latency, + simple_link->m_bw_multiplier); } void diff --git a/src/mem/slicc/symbols/StateMachine.py b/src/mem/slicc/symbols/StateMachine.py --- a/src/mem/slicc/symbols/StateMachine.py +++ b/src/mem/slicc/symbols/StateMachine.py @@ -578,7 +578,7 @@ vnet_dir_set.add((vnet,network)) code(''' -m_net_ptr->set${network}NetQueue(m_version + base, $vid->getOrdered(), $vnet, +m_net_ptr->set${network}NetQueue(this, $vid->getOrdered(), $vnet, "$vnet_type", $vid); ''') # Set Priority diff --git a/src/mem/ruby/network/garnet/flexible-pipeline/GarnetNetwork.cc b/src/mem/ruby/network/garnet/flexible-pipeline/GarnetNetwork.cc --- a/src/mem/ruby/network/garnet/flexible-pipeline/GarnetNetwork.cc +++ b/src/mem/ruby/network/garnet/flexible-pipeline/GarnetNetwork.cc @@ -56,11 +56,6 @@ Router* router = safe_cast(*i); m_routers.push_back(router); } - - for (int i=0; i < m_nodes; i++) { - NetworkInterface *ni = safe_cast(p->netifs[i]); - m_nis.push_back(ni); - } } void @@ -78,9 +73,21 @@ router->init_net_ptr(this); } - for (int i=0; i < m_nodes; i++) { - m_nis[i]->init_net_ptr(this); - m_nis[i]->addNode(m_toNetQueues[i], m_fromNetQueues[i]); + auto it = m_toNetQueues.begin(); + auto jt = m_fromNetQueues.begin(); + for (int i=0; i < m_nodes; i++, it++, jt++) { + assert(it != m_toNetQueues.end()); + assert(jt != m_fromNetQueues.end()); + assert((*it).first == (*jt).first); + + NetworkInterface *ni = + safe_cast(params()->netifs[i]); + const AbstractController *c = + safe_cast((*it).first); + + m_nis.insert(make_pair(c, ni)); + ni->init_net_ptr(this); + ni->addNode((*it).second, (*jt).second); } m_topology_ptr->createLinks(this); @@ -89,48 +96,49 @@ GarnetNetwork::~GarnetNetwork() { deletePointers(m_routers); - deletePointers(m_nis); deletePointers(m_links); + + for (auto it : m_nis) + delete it.second; } void -GarnetNetwork::makeInLink(NodeID src, SwitchID dest, BasicLink* link, +GarnetNetwork::makeInLink(SimObject *src, SimObject *dest, BasicLink* link, LinkDirection direction, const NetDest& routing_table_entry) { - assert(src < m_nodes); - GarnetExtLink* garnet_link = safe_cast(link); NetworkLink *net_link = garnet_link->m_network_links[direction]; net_link->init_net_ptr(this); m_links.push_back(net_link); - m_routers[dest]->addInPort(net_link); - m_nis[src]->addOutPort(net_link); + + Router *d = safe_cast(dest); + d->addInPort(net_link); + AbstractController *c = safe_cast(src); + m_nis[c]->addOutPort(net_link); } void -GarnetNetwork::makeOutLink(SwitchID src, NodeID dest, BasicLink* link, +GarnetNetwork::makeOutLink(SimObject *src, SimObject *dest, BasicLink* link, LinkDirection direction, const NetDest& routing_table_entry) { - assert(dest < m_nodes); - assert(src < m_routers.size()); - assert(m_routers[src] != NULL); - GarnetExtLink* garnet_link = safe_cast(link); NetworkLink *net_link = garnet_link->m_network_links[direction]; net_link->init_net_ptr(this); m_links.push_back(net_link); - m_routers[src]->addOutPort(net_link, routing_table_entry, - link->m_weight); - m_nis[dest]->addInPort(net_link); + + Router *s = safe_cast(src); + s->addOutPort(net_link, routing_table_entry, link->m_weight); + AbstractController *c = safe_cast(dest); + m_nis[c]->addInPort(net_link); } void -GarnetNetwork::makeInternalLink(SwitchID src, SwitchID dest, BasicLink* link, - LinkDirection direction, +GarnetNetwork::makeInternalLink(SimObject *src, SimObject *dest, + BasicLink* link, LinkDirection direction, const NetDest& routing_table_entry) { GarnetIntLink* garnet_link = safe_cast(link); @@ -138,9 +146,11 @@ net_link->init_net_ptr(this); m_links.push_back(net_link); - m_routers[dest]->addInPort(net_link); - m_routers[src]->addOutPort(net_link, routing_table_entry, - link->m_weight); + + Router *s = safe_cast(src); + s->addOutPort(net_link, routing_table_entry, link->m_weight); + Router *d = safe_cast(dest); + d->addInPort(net_link); } /* @@ -156,8 +166,8 @@ } } - for (unsigned int i = 0; i < m_nis.size(); ++i) { - if (m_nis[i]->functionalRead(pkt, block_size_bits)) { + for (auto ni : m_nis) { + if (ni.second->functionalRead(pkt, block_size_bits)) { return true; } } @@ -181,9 +191,9 @@ m_routers[i]->functionalWrite(pkt, block_size_bits); } - for (unsigned int i = 0; i < m_nis.size(); ++i) { + for (auto ni : m_nis) { num_functional_writes += - m_nis[i]->functionalWrite(pkt, block_size_bits); + ni.second->functionalWrite(pkt, block_size_bits); } for (unsigned int i = 0; i < m_links.size(); ++i) { diff --git a/src/mem/ruby/network/Topology.hh b/src/mem/ruby/network/Topology.hh --- a/src/mem/ruby/network/Topology.hh +++ b/src/mem/ruby/network/Topology.hh @@ -51,7 +51,7 @@ class NetDest; class Network; -typedef std::vector > Matrix; +typedef std::map > Matrix; struct LinkEntry { @@ -59,7 +59,7 @@ LinkDirection direction; }; -typedef std::map, LinkEntry> LinkMap; +typedef std::map, LinkEntry> LinkMap; class Topology { @@ -67,44 +67,26 @@ Topology(uint32_t num_routers, const std::vector &ext_links, const std::vector &int_links); - uint32_t numSwitches() const { return m_number_of_switches; } void createLinks(Network *net); - void print(std::ostream& out) const { out << "[Topology]"; } private: - void addLink(SwitchID src, SwitchID dest, BasicLink* link, + void initializeMatrix(Matrix &m, int value); + + void addLink(SimObject *src, SimObject *dest, BasicLink* link, LinkDirection dir); - void makeLink(Network *net, SwitchID src, SwitchID dest, + void makeLink(Network *net, SimObject *src, SimObject *dest, const NetDest& routing_table_entry); // Helper functions based on chapter 29 of Cormen et al. - void extend_shortest_path(Matrix ¤t_dist, Matrix &latencies, - Matrix &inter_switches); + void shortest_path(Matrix ¤t_dist); - std::vector> shortest_path(const Matrix &weights, - Matrix &latencies, Matrix &inter_switches); + bool link_is_shortest_path_to_node(SimObject *src, SimObject *next, + SimObject *final, const Matrix &weights, const Matrix &dist); - bool link_is_shortest_path_to_node(SwitchID src, SwitchID next, - SwitchID final, const Matrix &weights, const Matrix &dist); - - NetDest shortest_path_to_node(SwitchID src, SwitchID next, + NetDest shortest_path_to_node(SimObject *src, SimObject *next, const Matrix &weights, const Matrix &dist); - const uint32_t m_nodes; - const uint32_t m_number_of_switches; - - std::vector m_ext_link_vector; - std::vector m_int_link_vector; - LinkMap m_link_map; }; -inline std::ostream& -operator<<(std::ostream& out, const Topology& obj) -{ - obj.print(out); - out << std::flush; - return out; -} - #endif // __MEM_RUBY_NETWORK_TOPOLOGY_HH__ diff --git a/src/mem/ruby/network/Topology.cc b/src/mem/ruby/network/Topology.cc --- a/src/mem/ruby/network/Topology.cc +++ b/src/mem/ruby/network/Topology.cc @@ -39,22 +39,10 @@ const int INFINITE_LATENCY = 10000; // Yes, this is a big hack -// Note: In this file, we use the first 2*m_nodes SwitchIDs to -// represent the input and output endpoint links. These really are -// not 'switches', as they will not have a Switch object allocated for -// them. The first m_nodes SwitchIDs are the links into the network, -// the second m_nodes set of SwitchIDs represent the the output queues -// of the network. - Topology::Topology(uint32_t num_routers, const vector &ext_links, const vector &int_links) - : m_nodes(ext_links.size()), m_number_of_switches(num_routers), - m_ext_link_vector(ext_links), m_int_link_vector(int_links) { - // Total nodes/controllers in network - assert(m_nodes > 1); - // analyze both the internal and external links, create data structures // Note that the python created links are bi-directional, but that the // topology and networks utilize uni-directional links. Thus each @@ -65,16 +53,11 @@ AbstractController *abs_cntrl = ext_link->params()->ext_node; BasicRouter *router = ext_link->params()->int_node; - int machine_base_idx = MachineType_base_number(abs_cntrl->getType()); - int ext_idx1 = machine_base_idx + abs_cntrl->getVersion(); - int ext_idx2 = ext_idx1 + m_nodes; - int int_idx = router->params()->router_id + 2*m_nodes; - // create the internal uni-directional links in both directions // the first direction is marked: In - addLink(ext_idx1, int_idx, ext_link, LinkDirection_In); + addLink(abs_cntrl, router, ext_link, LinkDirection_In); // the first direction is marked: Out - addLink(int_idx, ext_idx2, ext_link, LinkDirection_Out); + addLink(router, abs_cntrl, ext_link, LinkDirection_Out); } for (vector::const_iterator i = int_links.begin(); @@ -83,121 +66,102 @@ BasicRouter *router_a = int_link->params()->node_a; BasicRouter *router_b = int_link->params()->node_b; - // Store the IntLink pointers for later - m_int_link_vector.push_back(int_link); - - int a = router_a->params()->router_id + 2*m_nodes; - int b = router_b->params()->router_id + 2*m_nodes; - // create the internal uni-directional links in both directions // the first direction is marked: In - addLink(a, b, int_link, LinkDirection_In); + addLink(router_a, router_b, int_link, LinkDirection_In); // the second direction is marked: Out - addLink(b, a, int_link, LinkDirection_Out); + addLink(router_b, router_a, int_link, LinkDirection_Out); + } +} + +void +Topology::initializeMatrix(Matrix &m, int value) +{ + for (LinkMap::const_iterator i = m_link_map.begin(); + i != m_link_map.end(); ++i) { + pair src_dest = (*i).first; + SimObject *src = src_dest.first; + + auto it = m.find(src); + if (it == m.end()) { + it = m.insert(make_pair(src, map())).first; + map &mp = (*it).second; + for (auto jt : m) { + if (jt.first != src && mp.find(jt.first) == mp.end()) { + mp.insert(make_pair(jt.first, value)); + } + } + } + + for (auto &jt : m) { + map &mp = jt.second; + auto kt = mp.find(src); + if (kt == mp.end()) { + if (src != jt.first) + mp.insert(make_pair(src, value)); + else + mp.insert(make_pair(src, 0)); + } + } } } void Topology::createLinks(Network *net) { - // Find maximum switchID - SwitchID max_switch_id = 0; - for (LinkMap::const_iterator i = m_link_map.begin(); - i != m_link_map.end(); ++i) { - std::pair src_dest = (*i).first; - max_switch_id = max(max_switch_id, src_dest.first); - max_switch_id = max(max_switch_id, src_dest.second); - } - - // Initialize weight, latency, and inter switched vectors - int num_switches = max_switch_id+1; - Matrix topology_weights(num_switches, - vector(num_switches, INFINITE_LATENCY)); - Matrix component_latencies(num_switches, - vector(num_switches, -1)); - Matrix component_inter_switches(num_switches, - vector(num_switches, 0)); - - // Set identity weights to zero - for (int i = 0; i < topology_weights.size(); i++) { - topology_weights[i][i] = 0; - } + Matrix topology_weights; + initializeMatrix(topology_weights, INFINITE_LATENCY); // Fill in the topology weights and bandwidth multipliers for (LinkMap::const_iterator i = m_link_map.begin(); i != m_link_map.end(); ++i) { - std::pair src_dest = (*i).first; + pair src_dest = (*i).first; BasicLink* link = (*i).second.link; - int src = src_dest.first; - int dst = src_dest.second; - component_latencies[src][dst] = link->m_latency; + SimObject *src = src_dest.first; + SimObject *dst = src_dest.second; topology_weights[src][dst] = link->m_weight; } // Walk topology and hookup the links - Matrix dist = shortest_path(topology_weights, component_latencies, - component_inter_switches); + Matrix dist = topology_weights; + shortest_path(dist); - for (int i = 0; i < topology_weights.size(); i++) { - for (int j = 0; j < topology_weights[i].size(); j++) { - int weight = topology_weights[i][j]; + for (auto it : topology_weights) { + for (auto jt : it.second) { + int weight = jt.second; if (weight > 0 && weight != INFINITE_LATENCY) { - NetDest destination_set = - shortest_path_to_node(i, j, topology_weights, dist); - makeLink(net, i, j, destination_set); + NetDest destination_set = shortest_path_to_node(it.first, + jt.first, topology_weights, dist); + makeLink(net, it.first, jt.first, destination_set); } } } } void -Topology::addLink(SwitchID src, SwitchID dest, BasicLink* link, +Topology::addLink(SimObject *src, SimObject *dest, BasicLink* link, LinkDirection dir) { - assert(src <= m_number_of_switches+m_nodes+m_nodes); - assert(dest <= m_number_of_switches+m_nodes+m_nodes); - - std::pair src_dest_pair; - LinkEntry link_entry; - - src_dest_pair.first = src; - src_dest_pair.second = dest; - link_entry.direction = dir; - link_entry.link = link; + pair src_dest_pair(src, dest); + LinkEntry link_entry = {link, dir}; m_link_map[src_dest_pair] = link_entry; } void -Topology::makeLink(Network *net, SwitchID src, SwitchID dest, +Topology::makeLink(Network *net, SimObject *src, SimObject *dest, const NetDest& routing_table_entry) { - // Make sure we're not trying to connect two end-point nodes - // directly together - assert(src >= 2 * m_nodes || dest >= 2 * m_nodes); + pair src_dest = {src, dest}; + LinkEntry link_entry = m_link_map[src_dest]; - std::pair src_dest; - LinkEntry link_entry; - - if (src < m_nodes) { - src_dest.first = src; - src_dest.second = dest; - link_entry = m_link_map[src_dest]; - net->makeInLink(src, dest - (2 * m_nodes), link_entry.link, + if (dynamic_cast(src)) { + net->makeInLink(src, dest, link_entry.link, link_entry.direction, routing_table_entry); - } else if (dest < 2*m_nodes) { - assert(dest >= m_nodes); - NodeID node = dest - m_nodes; - src_dest.first = src; - src_dest.second = dest; - link_entry = m_link_map[src_dest]; - net->makeOutLink(src - (2 * m_nodes), node, link_entry.link, + } else if (dynamic_cast(dest)) { + net->makeOutLink(src, dest, link_entry.link, link_entry.direction, routing_table_entry); } else { - assert((src >= 2 * m_nodes) && (dest >= 2 * m_nodes)); - src_dest.first = src; - src_dest.second = dest; - link_entry = m_link_map[src_dest]; - net->makeInternalLink(src - (2 * m_nodes), dest - (2 * m_nodes), + net->makeInternalLink(src, dest, link_entry.link, link_entry.direction, routing_table_entry); } @@ -206,93 +170,58 @@ // The following all-pairs shortest path algorithm is based on the // discussion from Cormen et al., Chapter 26.1. void -Topology::extend_shortest_path(Matrix ¤t_dist, Matrix &latencies, - Matrix &inter_switches) +Topology::shortest_path(Matrix ¤t_dist) { - bool change = true; - int nodes = current_dist.size(); + for (auto &kt : current_dist) { + for (auto &it : current_dist) { + for (auto &jt : it.second) { + int minimum = jt.second; + auto ikt = it.second.find(kt.first); + assert(ikt != it.second.end()); - while (change) { - change = false; - for (int i = 0; i < nodes; i++) { - for (int j = 0; j < nodes; j++) { - int minimum = current_dist[i][j]; - int previous_minimum = minimum; - int intermediate_switch = -1; - for (int k = 0; k < nodes; k++) { - minimum = min(minimum, - current_dist[i][k] + current_dist[k][j]); - if (previous_minimum != minimum) { - intermediate_switch = k; - inter_switches[i][j] = - inter_switches[i][k] + - inter_switches[k][j] + 1; - } - previous_minimum = minimum; - } - if (current_dist[i][j] != minimum) { - change = true; - current_dist[i][j] = minimum; - assert(intermediate_switch >= 0); - assert(intermediate_switch < latencies[i].size()); - latencies[i][j] = latencies[i][intermediate_switch] + - latencies[intermediate_switch][j]; - } + auto kjt = kt.second.find(jt.first); + assert(kjt != kt.second.end()); + + jt.second = min(minimum, (*ikt).second + (*kjt).second); } } } } -Matrix -Topology::shortest_path(const Matrix &weights, Matrix &latencies, - Matrix &inter_switches) -{ - Matrix dist = weights; - extend_shortest_path(dist, latencies, inter_switches); - return dist; -} - bool -Topology::link_is_shortest_path_to_node(SwitchID src, SwitchID next, - SwitchID final, const Matrix &weights, +Topology::link_is_shortest_path_to_node(SimObject *src, SimObject *next, + SimObject *final, + const Matrix &weights, const Matrix &dist) { - return weights[src][next] + dist[next][final] == dist[src][final]; + int weight_src_next = + (*((*(weights.find(src))).second.find(next))).second; + int dist_next_final = + (*((*(dist.find(next))).second.find(final))).second; + int dist_src_final = (*((*(dist.find(src))).second.find(final))).second; + return weight_src_next + dist_next_final == dist_src_final; } NetDest -Topology::shortest_path_to_node(SwitchID src, SwitchID next, +Topology::shortest_path_to_node(SimObject *src, SimObject *next, const Matrix &weights, const Matrix &dist) { NetDest result; - int d = 0; - int machines; - int max_machines; + for (auto dt : weights) { + AbstractController *c = dynamic_cast(dt.first); + if (c == nullptr) + continue; - machines = MachineType_NUM; - max_machines = MachineType_base_number(MachineType_NUM); - - for (int m = 0; m < machines; m++) { - for (NodeID i = 0; i < MachineType_base_count((MachineType)m); i++) { - // we use "d+max_machines" below since the "destination" - // switches for the machines are numbered - // [MachineType_base_number(MachineType_NUM)... - // 2*MachineType_base_number(MachineType_NUM)-1] for the - // component network - if (link_is_shortest_path_to_node(src, next, d + max_machines, - weights, dist)) { - MachineID mach = {(MachineType)m, i}; - result.add(mach); - } - d++; + if (link_is_shortest_path_to_node(src, next, dt.first, weights, + dist)) { + MachineID mach = c->getMachineID(); + result.add(mach); } } DPRINTF(RubyNetwork, "Returning shortest path\n" - "(src-(2*max_machines)): %d, (next-(2*max_machines)): %d, " - "src: %d, next: %d, result: %s\n", - (src-(2*max_machines)), (next-(2*max_machines)), - src, next, result); + "src: %s, next: %s, result: %s\n", + src->name(), next->name(), result); return result; } diff --git a/src/mem/ruby/network/garnet/fixed-pipeline/GarnetNetwork_d.hh b/src/mem/ruby/network/garnet/fixed-pipeline/GarnetNetwork_d.hh --- a/src/mem/ruby/network/garnet/fixed-pipeline/GarnetNetwork_d.hh +++ b/src/mem/ruby/network/garnet/fixed-pipeline/GarnetNetwork_d.hh @@ -69,13 +69,13 @@ } // Methods used by Topology to setup the network - void makeOutLink(SwitchID src, NodeID dest, BasicLink* link, + void makeOutLink(SimObject *src, SimObject *dest, BasicLink* link, LinkDirection direction, const NetDest& routing_table_entry); - void makeInLink(NodeID src, SwitchID dest, BasicLink* link, + void makeInLink(SimObject *src, SimObject *dest, BasicLink* link, LinkDirection direction, const NetDest& routing_table_entry); - void makeInternalLink(SwitchID src, SwitchID dest, BasicLink* link, + void makeInternalLink(SimObject *src, SimObject *dest, BasicLink* link, LinkDirection direction, const NetDest& routing_table_entry); @@ -91,7 +91,8 @@ std::vector m_routers; // All Routers in Network std::vector m_links; // All links in the network std::vector m_creditlinks; // All links in net - std::vector m_nis; // All NI's in Network + // All NI's in Network + std::map m_nis; int m_buffers_per_data_vc; int m_buffers_per_ctrl_vc; diff --git a/src/mem/ruby/network/garnet/fixed-pipeline/GarnetNetwork_d.cc b/src/mem/ruby/network/garnet/fixed-pipeline/GarnetNetwork_d.cc --- a/src/mem/ruby/network/garnet/fixed-pipeline/GarnetNetwork_d.cc +++ b/src/mem/ruby/network/garnet/fixed-pipeline/GarnetNetwork_d.cc @@ -69,14 +69,6 @@ // initialize the router's network pointers router->init_net_ptr(this); } - - // record the network interfaces - for (vector::const_iterator i = p->netifs.begin(); - i != p->netifs.end(); ++i) { - NetworkInterface_d *ni = safe_cast(*i); - m_nis.push_back(ni); - ni->init_net_ptr(this); - } } void @@ -84,8 +76,21 @@ { BaseGarnetNetwork::init(); - for (int i=0; i < m_nodes; i++) { - m_nis[i]->addNode(m_toNetQueues[i], m_fromNetQueues[i]); + auto it = m_toNetQueues.begin(); + auto jt = m_fromNetQueues.begin(); + for (int i=0; i < m_nodes; i++, it++, jt++) { + assert(it != m_toNetQueues.end()); + assert(jt != m_fromNetQueues.end()); + assert((*it).first == (*jt).first); + + NetworkInterface_d *ni = + safe_cast(params()->netifs[i]); + const AbstractController *c = + safe_cast((*it).first); + + m_nis.insert(make_pair(c, ni)); + ni->init_net_ptr(this); + ni->addNode((*it).second, (*jt).second); } // The topology pointer should have already been initialized in the @@ -114,9 +119,11 @@ GarnetNetwork_d::~GarnetNetwork_d() { deletePointers(m_routers); - deletePointers(m_nis); deletePointers(m_links); deletePointers(m_creditlinks); + + for (auto it : m_nis) + delete it.second; } /* @@ -127,12 +134,10 @@ */ void -GarnetNetwork_d::makeInLink(NodeID src, SwitchID dest, BasicLink* link, +GarnetNetwork_d::makeInLink(SimObject *src, SimObject *dest, BasicLink* link, LinkDirection direction, const NetDest& routing_table_entry) { - assert(src < m_nodes); - GarnetExtLink_d* garnet_link = safe_cast(link); NetworkLink_d* net_link = garnet_link->m_network_links[direction]; CreditLink_d* credit_link = garnet_link->m_credit_links[direction]; @@ -140,8 +145,11 @@ m_links.push_back(net_link); m_creditlinks.push_back(credit_link); - m_routers[dest]->addInPort(net_link, credit_link); - m_nis[src]->addOutPort(net_link, credit_link); + + Router_d *dest_router = safe_cast(dest); + dest_router->addInPort(net_link, credit_link); + AbstractController *src_cont = safe_cast(src); + m_nis[src_cont]->addOutPort(net_link, credit_link); } /* @@ -151,14 +159,11 @@ */ void -GarnetNetwork_d::makeOutLink(SwitchID src, NodeID dest, BasicLink* link, +GarnetNetwork_d::makeOutLink(SimObject *src, SimObject *dest, + BasicLink* link, LinkDirection direction, const NetDest& routing_table_entry) { - assert(dest < m_nodes); - assert(src < m_routers.size()); - assert(m_routers[src] != NULL); - GarnetExtLink_d* garnet_link = safe_cast(link); NetworkLink_d* net_link = garnet_link->m_network_links[direction]; CreditLink_d* credit_link = garnet_link->m_credit_links[direction]; @@ -166,9 +171,11 @@ m_links.push_back(net_link); m_creditlinks.push_back(credit_link); - m_routers[src]->addOutPort(net_link, routing_table_entry, - link->m_weight, credit_link); - m_nis[dest]->addInPort(net_link, credit_link); + Router_d *src_router = safe_cast(src); + src_router->addOutPort(net_link, routing_table_entry, + link->m_weight, credit_link); + AbstractController *dest_cont = safe_cast(dest); + m_nis[dest_cont]->addInPort(net_link, credit_link); } /* @@ -176,7 +183,8 @@ */ void -GarnetNetwork_d::makeInternalLink(SwitchID src, SwitchID dest, BasicLink* link, +GarnetNetwork_d::makeInternalLink(SimObject *src, SimObject *dest, + BasicLink* link, LinkDirection direction, const NetDest& routing_table_entry) { @@ -187,9 +195,11 @@ m_links.push_back(net_link); m_creditlinks.push_back(credit_link); - m_routers[dest]->addInPort(net_link, credit_link); - m_routers[src]->addOutPort(net_link, routing_table_entry, - link->m_weight, credit_link); + Router_d *dest_router = safe_cast(dest); + dest_router->addInPort(net_link, credit_link); + Router_d *src_router = safe_cast(src); + src_router->addOutPort(net_link, routing_table_entry, + link->m_weight, credit_link); } void @@ -250,9 +260,9 @@ m_routers[i]->functionalWrite(pkt, block_size_bits); } - for (unsigned int i = 0; i < m_nis.size(); ++i) { + for (auto ni : m_nis) { num_functional_writes += - m_nis[i]->functionalWrite(pkt, block_size_bits); + ni.second->functionalWrite(pkt, block_size_bits); } for (unsigned int i = 0; i < m_links.size(); ++i) { diff --git a/src/mem/ruby/network/garnet/flexible-pipeline/GarnetNetwork.hh b/src/mem/ruby/network/garnet/flexible-pipeline/GarnetNetwork.hh --- a/src/mem/ruby/network/garnet/flexible-pipeline/GarnetNetwork.hh +++ b/src/mem/ruby/network/garnet/flexible-pipeline/GarnetNetwork.hh @@ -60,13 +60,13 @@ void print(std::ostream& out) const; // Methods used by Topology to setup the network - void makeOutLink(SwitchID src, NodeID dest, BasicLink* link, + void makeOutLink(SimObject *src, SimObject *dest, BasicLink* link, LinkDirection direction, const NetDest& routing_table_entry); - void makeInLink(NodeID src, SwitchID dest, BasicLink* link, + void makeInLink(SimObject *src, SimObject *dest, BasicLink* link, LinkDirection direction, const NetDest& routing_table_entry); - void makeInternalLink(SwitchID src, SwitchID dest, BasicLink* link, + void makeInternalLink(SimObject *src, SimObject *dest, BasicLink* link, LinkDirection direction, const NetDest& routing_table_entry); @@ -84,7 +84,8 @@ std::vector m_routers; // All Routers in Network std::vector m_links; // All links in network - std::vector m_nis; // All NI's in Network + // All NI's in Network + std::map m_nis; int m_buffer_size; int m_number_of_pipe_stages; diff --git a/src/mem/ruby/network/Network.hh b/src/mem/ruby/network/Network.hh --- a/src/mem/ruby/network/Network.hh +++ b/src/mem/ruby/network/Network.hh @@ -70,22 +70,24 @@ static uint32_t MessageSizeType_to_int(MessageSizeType size_type); // returns the queue requested for the given component - void setToNetQueue(NodeID id, bool ordered, int netNumber, - std::string vnet_type, MessageBuffer *b); - virtual void setFromNetQueue(NodeID id, bool ordered, int netNumber, - std::string vnet_type, MessageBuffer *b); + void setToNetQueue(const AbstractController *c, bool ordered, + int netNumber, const std::string &vnet_type, + MessageBuffer *b); + void setFromNetQueue(const AbstractController *c, bool ordered, + int netNumber, const std::string &vnet_type, + MessageBuffer *b); - virtual void checkNetworkAllocation(NodeID id, bool ordered, - int network_num, std::string vnet_type); + void checkNetworkAllocation(bool ordered, int network_num, + const std::string &vnet_type); - virtual void makeOutLink(SwitchID src, NodeID dest, BasicLink* link, - LinkDirection direction, + virtual void makeOutLink(SimObject *src, SimObject *dest, + BasicLink* link, LinkDirection direction, const NetDest& routing_table_entry) = 0; - virtual void makeInLink(NodeID src, SwitchID dest, BasicLink* link, + virtual void makeInLink(SimObject *src, SimObject *dest, BasicLink* link, LinkDirection direction, const NetDest& routing_table_entry) = 0; - virtual void makeInternalLink(SwitchID src, SwitchID dest, BasicLink* link, - LinkDirection direction, + virtual void makeInternalLink(SimObject *src, SimObject *dest, + BasicLink* link, LinkDirection direction, const NetDest& routing_table_entry) = 0; virtual void collateStats() = 0; @@ -114,8 +116,10 @@ static uint32_t m_data_msg_size; // vector of queues from the components - std::vector > m_toNetQueues; - std::vector > m_fromNetQueues; + std::map> m_toNetQueues; + std::map> m_fromNetQueues; std::vector m_ordered; private: # Node ID 75e7a63a07c49086a8a67fb19503e6ca1579eea9 # Parent 5103da28c1da89765d87baa966d6961d6e6d7a0b diff --git a/src/mem/ruby/network/Network.cc b/src/mem/ruby/network/Network.cc --- a/src/mem/ruby/network/Network.cc +++ b/src/mem/ruby/network/Network.cc @@ -51,13 +51,6 @@ m_topology_ptr = new Topology(p->routers.size(), p->ext_links, p->int_links); - // 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_ordered.resize(m_virtual_networks); m_vnet_type_names.resize(m_virtual_networks); @@ -85,14 +78,15 @@ Network::~Network() { - for (int node = 0; node < m_nodes; node++) { - - // Delete the Message Buffers - for (auto& it : m_toNetQueues[node]) { + // Delete the Message Buffers + for (auto jt : m_toNetQueues) { + for (auto& it : jt.second) { delete it; } + } - for (auto& it : m_fromNetQueues[node]) { + for (auto jt : m_fromNetQueues) { + for (auto& it : jt.second) { delete it; } } @@ -130,11 +124,9 @@ } void -Network::checkNetworkAllocation(NodeID id, bool ordered, - int network_num, - std::string vnet_type) +Network::checkNetworkAllocation(bool ordered, int network_num, + const std::string &vnet_type) { - fatal_if(id >= m_nodes, "Node ID is out of range"); fatal_if(network_num >= m_virtual_networks, "Network id is out of range"); if (ordered) { @@ -146,23 +138,39 @@ void -Network::setToNetQueue(NodeID id, bool ordered, int network_num, - std::string vnet_type, MessageBuffer *b) +Network::setToNetQueue(const AbstractController *c, bool ordered, + int network_num, const std::string &vnet_type, + MessageBuffer *b) { - checkNetworkAllocation(id, ordered, network_num, vnet_type); - while (m_toNetQueues[id].size() <= network_num) { - m_toNetQueues[id].push_back(nullptr); + checkNetworkAllocation(ordered, network_num, vnet_type); + auto it = m_toNetQueues.find(c); + if (it == m_toNetQueues.end()) { + it = m_toNetQueues.insert( + make_pair(c, std::vector())).first; } - m_toNetQueues[id][network_num] = b; + + std::vector &queues = (*it).second; + while (queues.size() <= network_num) { + queues.push_back(nullptr); + } + queues[network_num] = b; } void -Network::setFromNetQueue(NodeID id, bool ordered, int network_num, - std::string vnet_type, MessageBuffer *b) +Network::setFromNetQueue(const AbstractController *c, bool ordered, + int network_num, const std::string &vnet_type, + MessageBuffer *b) { - checkNetworkAllocation(id, ordered, network_num, vnet_type); - while (m_fromNetQueues[id].size() <= network_num) { - m_fromNetQueues[id].push_back(nullptr); + checkNetworkAllocation(ordered, network_num, vnet_type); + auto it = m_fromNetQueues.find(c); + if (it == m_fromNetQueues.end()) { + it = m_fromNetQueues.insert( + make_pair(c, std::vector())).first; } - m_fromNetQueues[id][network_num] = b; + + std::vector &queues = (*it).second; + while (queues.size() <= network_num) { + queues.push_back(nullptr); + } + queues[network_num] = b; }