class NetworkClass(SimpleNetwork): pass
class IntLinkClass(SimpleIntLink): pass
class ExtLinkClass(SimpleExtLink): pass
- class RouterClass(BasicRouter): pass
+ class RouterClass(Switch): pass
#
# Important: the topology must be instantiated before the network and after
//
// ID in relation to other routers in the system
//
- int m_id;
+ uint32_t m_id;
};
inline std::ostream&
#include "mem/protocol/MachineType.hh"
#include "mem/ruby/common/NetDest.hh"
#include "mem/ruby/network/BasicLink.hh"
-#include "mem/ruby/network/BasicRouter.hh"
#include "mem/ruby/network/Network.hh"
#include "mem/ruby/network/Topology.hh"
#include "mem/ruby/slicc_interface/AbstractController.hh"
const int INFINITE_LATENCY = 10000; // Yes, this is a big hack
-class BasicRouter;
-
// 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
#include "mem/protocol/LinkDirection.hh"
#include "mem/ruby/common/TypeDefines.hh"
+#include "mem/ruby/network/BasicRouter.hh"
#include "params/Topology.hh"
#include "sim/sim_object.hh"
"virtual channels per virtual network")
virt_nets = Param.Int(Parent.number_of_virtual_networks,
"number of virtual networks")
-
-
Router::Router(const Params *p)
: BasicRouter(p), FlexibleConsumer(this)
{
- m_id = p->router_id;
m_virtual_networks = p->virt_nets;
m_vc_per_vnet = p->vcs_per_vnet;
m_round_robin_inport = 0;
}
private:
- int m_id;
int m_virtual_networks, m_num_vcs, m_vc_per_vnet;
GarnetNetwork *m_net_ptr;
std::vector<int> m_vc_round_robin; // For scheduling of out source queues
#include "mem/ruby/buffers/MessageBuffer.hh"
#include "mem/ruby/network/simple/PerfectSwitch.hh"
#include "mem/ruby/network/simple/SimpleNetwork.hh"
-#include "mem/ruby/profiler/Profiler.hh"
+#include "mem/ruby/network/simple/Switch.hh"
#include "mem/ruby/slicc_interface/NetworkMessage.hh"
-#include "mem/ruby/system/System.hh"
using namespace std;
return (l1.m_value < l2.m_value);
}
-PerfectSwitch::PerfectSwitch(SwitchID sid, SimpleNetwork* network_ptr)
- : Consumer(network_ptr)
+PerfectSwitch::PerfectSwitch(SwitchID sid, Switch *sw, uint32_t virt_nets)
+ : Consumer(sw)
{
- m_virtual_networks = network_ptr->getNumberOfVirtualNetworks();
m_switch_id = sid;
m_round_robin_start = 0;
- m_network_ptr = network_ptr;
m_wakeups_wo_switch = 0;
+ m_virtual_networks = virt_nets;
+}
+
+void
+PerfectSwitch::init(SimpleNetwork *network_ptr)
+{
+ m_network_ptr = network_ptr;
for(int i = 0;i < m_virtual_networks;++i)
{
#include <vector>
#include "mem/ruby/common/Consumer.hh"
-#include "mem/ruby/common/Global.hh"
class MessageBuffer;
class NetDest;
class SimpleNetwork;
+class Switch;
struct LinkOrder
{
class PerfectSwitch : public Consumer
{
public:
- PerfectSwitch(SwitchID sid, SimpleNetwork* network_ptr);
+ PerfectSwitch(SwitchID sid, Switch *, uint32_t);
~PerfectSwitch();
std::string name()
{ return csprintf("PerfectSwitch-%i", m_switch_id); }
+ void init(SimpleNetwork *);
void addInPort(const std::vector<MessageBuffer*>& in);
void addOutPort(const std::vector<MessageBuffer*>& out,
const NetDest& routing_table_entry);
std::vector<std::vector<MessageBuffer*> > m_out;
std::vector<NetDest> m_routing_table;
std::vector<LinkOrder> m_link_order;
- int m_virtual_networks;
+
+ uint32_t m_virtual_networks;
int m_round_robin_start;
int m_wakeups_wo_switch;
+
SimpleNetwork* m_network_ptr;
std::vector<int> m_pending_message_count;
};
new MessageBuffer(csprintf("fromNet node %d j %d", node, j));
}
}
+
+ // record the routers
+ for (vector<BasicRouter*>::const_iterator i =
+ m_topology_ptr->params()->routers.begin();
+ i != m_topology_ptr->params()->routers.end(); ++i) {
+ Switch* s = safe_cast<Switch*>(*i);
+ m_switch_ptr_vector.push_back(s);
+ s->init_net_ptr(this);
+ }
}
void
// The topology pointer should have already been initialized in
// the parent class network constructor.
assert(m_topology_ptr != NULL);
- int number_of_switches = m_topology_ptr->numSwitches();
- for (int i = 0; i < number_of_switches; i++) {
- m_switch_ptr_vector.push_back(new Switch(i, this));
- }
-
// false because this isn't a reconfiguration
m_topology_ptr->createLinks(this, false);
}
if (total_msg_counts[type] > 0) {
out << "total_msg_count_" << type << ": " << total_msg_counts[type]
- << " " << total_msg_counts[type] *
- uint64(RubySystem::getNetwork()->MessageSizeType_to_int(type))
+ << " " << total_msg_counts[type] *
+ uint64(MessageSizeType_to_int(type))
<< endl;
total_msgs += total_msg_counts[type];
total_bytes += total_msg_counts[type] *
- uint64(RubySystem::getNetwork()->MessageSizeType_to_int(type));
-
+ uint64(MessageSizeType_to_int(type));
}
}
# Brad Beckmann
from m5.params import *
+from m5.proxy import *
from Network import RubyNetwork
+from BasicRouter import BasicRouter
class SimpleNetwork(RubyNetwork):
type = 'SimpleNetwork'
"default buffer size; 0 indicates infinite buffering");
endpoint_bandwidth = Param.Int(1000, "bandwidth adjustment factor");
adaptive_routing = Param.Bool(False, "enable adaptive routing");
+
+class Switch(BasicRouter):
+ type = 'Switch'
+ cxx_class = 'Switch'
+ virt_nets = Param.Int(Parent.number_of_virtual_networks,
+ "number of virtual networks")
using m5::stl_helpers::deletePointers;
using m5::stl_helpers::operator<<;
-Switch::Switch(SwitchID sid, SimpleNetwork* network_ptr)
+Switch::Switch(const Params *p) : BasicRouter(p)
{
- m_perfect_switch_ptr = new PerfectSwitch(sid, network_ptr);
- m_switch_id = sid;
+ m_perfect_switch_ptr = new PerfectSwitch(m_id, this, p->virt_nets);
}
Switch::~Switch()
deletePointers(m_buffers_to_free);
}
+void
+Switch::init()
+{
+ BasicRouter::init();
+ m_perfect_switch_ptr->init(m_network_ptr);
+}
+
void
Switch::addInPort(const vector<MessageBuffer*>& in)
{
Switch::addOutPort(const vector<MessageBuffer*>& out,
const NetDest& routing_table_entry, int link_latency, int bw_multiplier)
{
- Throttle* throttle_ptr = NULL;
- SimpleNetwork* net_ptr =
- safe_cast<SimpleNetwork*>(RubySystem::getNetwork());
-
// Create a throttle
- throttle_ptr = new Throttle(m_switch_id, m_throttles.size(), link_latency,
- bw_multiplier, net_ptr->getEndpointBandwidth(),
- net_ptr);
+ Throttle* throttle_ptr = new Throttle(m_id, m_throttles.size(),
+ link_latency, bw_multiplier, m_network_ptr->getEndpointBandwidth(),
+ this);
m_throttles.push_back(throttle_ptr);
// Create one buffer per vnet (these are intermediaryQueues)
MessageBuffer* buffer_ptr = new MessageBuffer;
// Make these queues ordered
buffer_ptr->setOrdering(true);
- if (net_ptr->getBufferSize() > 0) {
- buffer_ptr->resize(net_ptr->getBufferSize());
+ if (m_network_ptr->getBufferSize() > 0) {
+ buffer_ptr->resize(m_network_ptr->getBufferSize());
}
intermediateBuffers.push_back(buffer_ptr);
m_buffers_to_free.push_back(buffer_ptr);
- }
+ }
// Hook the queues to the PerfectSwitch
m_perfect_switch_ptr->addOutPort(intermediateBuffers, routing_table_entry);
void
Switch::printStats(std::ostream& out) const
{
- ccprintf(out, "switch_%d_inlinks: %d\n", m_switch_id,
+ ccprintf(out, "switch_%d_inlinks: %d\n", m_id,
m_perfect_switch_ptr->getInLinks());
- ccprintf(out, "switch_%d_outlinks: %d\n", m_switch_id,
+ ccprintf(out, "switch_%d_outlinks: %d\n", m_id,
m_perfect_switch_ptr->getOutLinks());
// Average link utilizations
throttle_count == 0 ? 0 : average_utilization / throttle_count;
// Individual link utilizations
- out << "links_utilized_percent_switch_" << m_switch_id << ": "
+ out << "links_utilized_percent_switch_" << m_id << ": "
<< average_utilization << endl;
for (int link = 0; link < m_throttles.size(); link++) {
Throttle* throttle_ptr = m_throttles[link];
if (throttle_ptr != NULL) {
- out << " links_utilized_percent_switch_" << m_switch_id
+ out << " links_utilized_percent_switch_" << m_id
<< "_link_" << link << ": "
<< throttle_ptr->getUtilization() << " bw: "
<< throttle_ptr->getLinkBandwidth()
if (sum == 0)
continue;
- out << " outgoing_messages_switch_" << m_switch_id
+ out << " outgoing_messages_switch_" << m_id
<< "_link_" << link << "_" << type << ": " << sum << " "
- << sum * RubySystem::getNetwork()->MessageSizeType_to_int(type)
+ << sum * m_network_ptr->MessageSizeType_to_int(type)
<< " ";
out << mct;
out << " base_latency: "
// FIXME printing
out << "[Switch]";
}
+
+Switch *
+SwitchParams::create()
+{
+ return new Switch(this);
+}
#include <iostream>
#include <vector>
+#include "mem/ruby/network/BasicRouter.hh"
+#include "params/Switch.hh"
+
class MessageBuffer;
class PerfectSwitch;
class NetDest;
class SimpleNetwork;
class Throttle;
-class Switch
+class Switch : public BasicRouter
{
public:
- Switch(SwitchID sid, SimpleNetwork* network_ptr);
+ typedef SwitchParams Params;
+ Switch(const Params *p);
~Switch();
+ void init();
void addInPort(const std::vector<MessageBuffer*>& in);
void addOutPort(const std::vector<MessageBuffer*>& out,
const NetDest& routing_table_entry, int link_latency,
void printStats(std::ostream& out) const;
void clearStats();
void print(std::ostream& out) const;
+ void init_net_ptr(SimpleNetwork* net_ptr) { m_network_ptr = net_ptr; }
private:
// Private copy constructor and assignment operator
SimpleNetwork* m_network_ptr;
std::vector<Throttle*> m_throttles;
std::vector<MessageBuffer*> m_buffers_to_free;
- SwitchID m_switch_id;
};
inline std::ostream&
projects / gem5.git / commitdiff