derek/gem5
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

ruby: network: revert some of the changes from ad9c042dce54

Browse Source 
The changeset ad9c042dce54 made changes to the structures under the network
directory to use a map of buffers instead of vector of buffers.
The reasoning was that not all vnets that are created are used and we
needlessly allocate more buffers than required and then iterate over them
while processing network messages.  But the move to map resulted in a slow
down which was pointed out by Andreas Hansson.  This patch moves things
back to using vector of message buffers.
This commit is contained in:
Nilay Vaish
2014-09-15 16:19:38 -05:00
parent 8d18713d28
commit 2ccdfc547d
14 changed files with 124 additions and 87 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/mem/ruby/network/Network.cc
View File

@@ -85,11 +85,11 @@ Network::~Network()
// Delete the Message Buffers
for (auto& it : m_toNetQueues[node]) {
delete it.second;
delete it;
}
for (auto& it : m_fromNetQueues[node]) {
delete it.second;
delete it;
}
}

4
src/mem/ruby/network/Network.hh
View File

@@ -112,8 +112,8 @@ class Network : public ClockedObject
static uint32_t m_data_msg_size;
// vector of queues from the components
std::vector<std::map<int, MessageBuffer*> > m_toNetQueues;
std::vector<std::map<int, MessageBuffer*> > m_fromNetQueues;
std::vector<std::vector<MessageBuffer*> > m_toNetQueues;
std::vector<std::vector<MessageBuffer*> > m_fromNetQueues;
std::vector<bool> m_in_use;
std::vector<bool> m_ordered;

6
src/mem/ruby/network/garnet/BaseGarnetNetwork.cc
View File

@@ -71,6 +71,9 @@ BaseGarnetNetwork::setToNetQueue(NodeID id, bool ordered, int network_num,
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);
}
m_toNetQueues[id][network_num] = b;
}
@@ -79,6 +82,9 @@ BaseGarnetNetwork::setFromNetQueue(NodeID id, bool ordered, int network_num,
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);
}
m_fromNetQueues[id][network_num] = b;
}

29
src/mem/ruby/network/garnet/fixed-pipeline/NetworkInterface_d.cc
View File

@@ -106,20 +106,23 @@ NetworkInterface_d::addOutPort(NetworkLink_d *out_link,
}
void
NetworkInterface_d::addNode(map<int, MessageBuffer *>& in,
map<int, MessageBuffer *>& out)
NetworkInterface_d::addNode(vector<MessageBuffer *>& in,
vector<MessageBuffer *>& out)
{
inNode_ptr = in;
outNode_ptr = out;
for (auto& it : in) {
// the protocol injects messages into the NI
it.second->setConsumer(this);
it.second->setReceiver(this);
if (it != nullptr) {
it->setConsumer(this);
it->setReceiver(this);
}
}
for (auto& it : out) {
it.second->setSender(this);
if (it != nullptr) {
it->setSender(this);
}
}
}
@@ -223,9 +226,11 @@ NetworkInterface_d::wakeup()
// Checking for messages coming from the protocol
// can pick up a message/cycle for each virtual net
for (auto it = inNode_ptr.begin(); it != inNode_ptr.end(); ++it) {
int vnet = (*it).first;
MessageBuffer *b = (*it).second;
for (int vnet = 0; vnet < inNode_ptr.size(); ++vnet) {
MessageBuffer *b = inNode_ptr[vnet];
if (b == nullptr) {
continue;
}
while (b->isReady()) { // Is there a message waiting
msg_ptr = b->peekMsgPtr();
@@ -355,9 +360,11 @@ void
NetworkInterface_d::checkReschedule()
{
for (const auto& it : inNode_ptr) {
MessageBuffer *b = it.second;
if (it == nullptr) {
continue;
}
while (b->isReady()) { // Is there a message waiting
while (it->isReady()) { // Is there a message waiting
scheduleEvent(Cycles(1));
return;
}

8
src/mem/ruby/network/garnet/fixed-pipeline/NetworkInterface_d.hh
View File

@@ -60,8 +60,8 @@ class NetworkInterface_d : public ClockedObject, public Consumer
void addOutPort(NetworkLink_d *out_link, CreditLink_d *credit_link);
void wakeup();
void addNode(std::map<int, MessageBuffer *> &inNode,
std::map<int, MessageBuffer *> &outNode);
void addNode(std::vector<MessageBuffer *> &inNode,
std::vector<MessageBuffer *> &outNode);
void print(std::ostream& out) const;
int get_vnet(int vc);
@@ -90,9 +90,9 @@ class NetworkInterface_d : public ClockedObject, public Consumer
std::vector<Cycles> m_ni_enqueue_time;
// The Message buffers that takes messages from the protocol
std::map<int, MessageBuffer *> inNode_ptr;
std::vector<MessageBuffer *> inNode_ptr;
// The Message buffers that provides messages to the protocol
std::map<int, MessageBuffer *> outNode_ptr;
std::vector<MessageBuffer *> outNode_ptr;
bool flitisizeMessage(MsgPtr msg_ptr, int vnet);
int calculateVC(int vnet);

29
src/mem/ruby/network/garnet/flexible-pipeline/NetworkInterface.cc
View File

@@ -90,20 +90,23 @@ NetworkInterface::addOutPort(NetworkLink *out_link)
}
void
NetworkInterface::addNode(map<int, MessageBuffer*>& in,
map<int, MessageBuffer*>& out)
NetworkInterface::addNode(vector<MessageBuffer*>& in,
vector<MessageBuffer*>& out)
{
inNode_ptr = in;
outNode_ptr = out;
for (auto& it: in) {
// the protocol injects messages into the NI
it.second->setConsumer(this);
it.second->setReceiver(this);
if (it != nullptr) {
it->setConsumer(this);
it->setReceiver(this);
}
}
for (auto& it : out) {
it.second->setSender(this);
if (it != nullptr) {
it->setSender(this);
}
}
}
@@ -242,9 +245,11 @@ NetworkInterface::wakeup()
//Checking for messages coming from the protocol
// can pick up a message/cycle for each virtual net
for (auto it = inNode_ptr.begin(); it != inNode_ptr.end(); ++it) {
int vnet = (*it).first;
MessageBuffer *b = (*it).second;
for (int vnet = 0; vnet < inNode_ptr.size(); ++vnet) {
MessageBuffer *b = inNode_ptr[vnet];
if (b == nullptr) {
continue;
}
while (b->isReady()) { // Is there a message waiting
msg_ptr = b->peekMsgPtr();
@@ -326,9 +331,11 @@ void
NetworkInterface::checkReschedule()
{
for (const auto& it : inNode_ptr) {
MessageBuffer *b = it.second;
if (it == nullptr) {
continue;
}
while (b->isReady()) { // Is there a message waiting
while (it->isReady()) { // Is there a message waiting
scheduleEvent(Cycles(1));
return;
}

8
src/mem/ruby/network/garnet/flexible-pipeline/NetworkInterface.hh
View File

@@ -56,8 +56,8 @@ class NetworkInterface : public ClockedObject, public FlexibleConsumer
void addInPort(NetworkLink *in_link);
void addOutPort(NetworkLink *out_link);
void addNode(std::map<int, MessageBuffer *> &inNode,
std::map<int, MessageBuffer *> &outNode);
void addNode(std::vector<MessageBuffer *> &inNode,
std::vector<MessageBuffer *> &outNode);
void wakeup();
void grant_vc(int out_port, int vc, Cycles grant_time);
@@ -93,10 +93,10 @@ class NetworkInterface : public ClockedObject, public FlexibleConsumer
std::vector<flitBuffer *> m_ni_buffers;
// The Message buffers that takes messages from the protocol
std::map<int, MessageBuffer *> inNode_ptr;
std::vector<MessageBuffer *> inNode_ptr;
// The Message buffers that provides messages to the protocol
std::map<int, MessageBuffer *> outNode_ptr;
std::vector<MessageBuffer *> outNode_ptr;
bool flitisizeMessage(MsgPtr msg_ptr, int vnet);
int calculateVC(int vnet);

34
src/mem/ruby/network/simple/PerfectSwitch.cc
View File

@@ -68,26 +68,30 @@ PerfectSwitch::init(SimpleNetwork *network_ptr)
}
void
PerfectSwitch::addInPort(const map<int, MessageBuffer*>& in)
PerfectSwitch::addInPort(const vector<MessageBuffer*>& in)
{
NodeID port = m_in.size();
m_in.push_back(in);
for (auto& it : in) {
it.second->setConsumer(this);
for (int i = 0; i < in.size(); ++i) {
if (in[i] != nullptr) {
in[i]->setConsumer(this);
string desc = csprintf("[Queue from port %s %s %s to PerfectSwitch]",
to_string(m_switch_id), to_string(port), to_string(it.first));
string desc =
csprintf("[Queue from port %s %s %s to PerfectSwitch]",
to_string(m_switch_id), to_string(port),
to_string(i));
it.second->setDescription(desc);
it.second->setIncomingLink(port);
it.second->setVnet(it.first);
in[i]->setDescription(desc);
in[i]->setIncomingLink(port);
in[i]->setVnet(i);
}
}
}
void
PerfectSwitch::addOutPort(const map<int, MessageBuffer*>& out,
const NetDest& routing_table_entry)
PerfectSwitch::addOutPort(const vector<MessageBuffer*>& out,
const NetDest& routing_table_entry)
{
// Setup link order
LinkOrder l;
@@ -131,10 +135,14 @@ PerfectSwitch::operateVnet(int vnet)
vector<NetDest> output_link_destinations;
// Is there a message waiting?
auto it = m_in[incoming].find(vnet);
if (it == m_in[incoming].end())
if (m_in[incoming].size() <= vnet) {
continue;
MessageBuffer *buffer = (*it).second;
}
MessageBuffer *buffer = m_in[incoming][vnet];
if (buffer == nullptr) {
continue;
}
while (buffer->isReady()) {
DPRINTF(RubyNetwork, "incoming: %d\n", incoming);

8
src/mem/ruby/network/simple/PerfectSwitch.hh
View File

@@ -65,8 +65,8 @@ class PerfectSwitch : public Consumer
{ return csprintf("PerfectSwitch-%i", m_switch_id); }
void init(SimpleNetwork *);
void addInPort(const std::map<int, MessageBuffer*>& in);
void addOutPort(const std::map<int, MessageBuffer*>& out,
void addInPort(const std::vector<MessageBuffer*>& in);
void addOutPort(const std::vector<MessageBuffer*>& out,
const NetDest& routing_table_entry);
int getInLinks() const { return m_in.size(); }
@@ -89,8 +89,8 @@ class PerfectSwitch : public Consumer
SwitchID m_switch_id;
// vector of queues from the components
std::vector<std::map<int, MessageBuffer*> > m_in;
std::vector<std::map<int, MessageBuffer*> > m_out;
std::vector<std::vector<MessageBuffer*> > m_in;
std::vector<std::vector<MessageBuffer*> > m_out;
std::vector<NetDest> m_routing_table;
std::vector<LinkOrder> m_link_order;

9
src/mem/ruby/network/simple/SimpleNetwork.cc
View File

@@ -117,7 +117,8 @@ SimpleNetwork::makeInternalLink(SwitchID src, SwitchID dest, BasicLink* link,
const NetDest& routing_table_entry)
{
// Create a set of new MessageBuffers
std::map<int, MessageBuffer*> queues;
std::vector<MessageBuffer*> queues(m_virtual_networks);
for (int i = 0; i < m_virtual_networks; i++) {
// allocate a buffer
MessageBuffer* buffer_ptr = new MessageBuffer;
@@ -158,6 +159,9 @@ SimpleNetwork::setToNetQueue(NodeID id, bool ordered, int network_num,
std::string vnet_type, MessageBuffer *b)
{
checkNetworkAllocation(id, ordered, network_num);
while (m_toNetQueues[id].size() <= network_num) {
m_toNetQueues[id].push_back(nullptr);
}
m_toNetQueues[id][network_num] = b;
}
@@ -166,6 +170,9 @@ SimpleNetwork::setFromNetQueue(NodeID id, bool ordered, int network_num,
std::string vnet_type, MessageBuffer *b)
{
checkNetworkAllocation(id, ordered, network_num);
while (m_fromNetQueues[id].size() <= network_num) {
m_fromNetQueues[id].push_back(nullptr);
}
m_fromNetQueues[id][network_num] = b;
}

18
src/mem/ruby/network/simple/Switch.cc
View File

@@ -64,17 +64,19 @@ Switch::init()
}
void
Switch::addInPort(const map<int, MessageBuffer*>& in)
Switch::addInPort(const vector<MessageBuffer*>& in)
{
m_perfect_switch->addInPort(in);
for (auto& it : in) {
it.second->setReceiver(this);
if (it != nullptr) {
it->setReceiver(this);
}
}
}
void
Switch::addOutPort(const map<int, MessageBuffer*>& out,
Switch::addOutPort(const vector<MessageBuffer*>& out,
const NetDest& routing_table_entry,
Cycles link_latency, int bw_multiplier)
{
@@ -87,10 +89,12 @@ Switch::addOutPort(const map<int, MessageBuffer*>& out,
m_throttles.push_back(throttle_ptr);
// Create one buffer per vnet (these are intermediaryQueues)
map<int, MessageBuffer*> intermediateBuffers;
vector<MessageBuffer*> intermediateBuffers;
for (auto& it : out) {
it.second->setSender(this);
for (int i = 0; i < out.size(); ++i) {
if (out[i] != nullptr) {
out[i]->setSender(this);
}
MessageBuffer* buffer_ptr = new MessageBuffer;
// Make these queues ordered
@@ -99,7 +103,7 @@ Switch::addOutPort(const map<int, MessageBuffer*>& out,
buffer_ptr->resize(m_network_ptr->getBufferSize());
}
intermediateBuffers[it.first] = buffer_ptr;
intermediateBuffers.push_back(buffer_ptr);
m_buffers_to_free.push_back(buffer_ptr);
buffer_ptr->setSender(this);

4
src/mem/ruby/network/simple/Switch.hh
View File

@@ -62,8 +62,8 @@ class Switch : public BasicRouter
~Switch();
void init();
void addInPort(const std::map<int, MessageBuffer*>& in);
void addOutPort(const std::map<int, MessageBuffer*>& out,
void addInPort(const std::vector<MessageBuffer*>& in);
void addOutPort(const std::vector<MessageBuffer*>& out,
const NetDest& routing_table_entry,
Cycles link_latency, int bw_multiplier);

39
src/mem/ruby/network/simple/Throttle.cc
View File

@@ -69,6 +69,8 @@ Throttle::init(NodeID node, Cycles link_latency,
int link_bandwidth_multiplier, int endpoint_bandwidth)
{
m_node = node;
m_vnets = 0;
assert(link_bandwidth_multiplier > 0);
m_link_bandwidth_multiplier = link_bandwidth_multiplier;
@@ -80,23 +82,19 @@ Throttle::init(NodeID node, Cycles link_latency,
}
void
Throttle::addLinks(const map<int, MessageBuffer*>& in_vec,
const map<int, MessageBuffer*>& out_vec)
Throttle::addLinks(const vector<MessageBuffer*>& in_vec,
const vector<MessageBuffer*>& out_vec)
{
assert(in_vec.size() == out_vec.size());
for (auto& it : in_vec) {
int vnet = it.first;
for (int vnet = 0; vnet < in_vec.size(); ++vnet) {
MessageBuffer *in_ptr = in_vec[vnet];
MessageBuffer *out_ptr = out_vec[vnet];
auto jt = out_vec.find(vnet);
assert(jt != out_vec.end());
MessageBuffer *in_ptr = it.second;
MessageBuffer *out_ptr = (*jt).second;
m_in[vnet] = in_ptr;
m_out[vnet] = out_ptr;
m_units_remaining[vnet] = 0;
m_vnets++;
m_units_remaining.push_back(0);
m_in.push_back(in_ptr);
m_out.push_back(out_ptr);
// Set consumer and description
in_ptr->setConsumer(this);
@@ -110,8 +108,9 @@ void
Throttle::operateVnet(int vnet, int &bw_remaining, bool &schedule_wakeup,
MessageBuffer *in, MessageBuffer *out)
{
assert(out != NULL);
assert(in != NULL);
if (out == nullptr || in == nullptr) {
return;
}
assert(m_units_remaining[vnet] >= 0);
while (bw_remaining > 0 && (in->isReady() || m_units_remaining[vnet] > 0) &&
@@ -178,16 +177,14 @@ Throttle::wakeup()
}
if (iteration_direction) {
for (auto& it : m_in) {
int vnet = it.first;
for (int vnet = 0; vnet < m_vnets; ++vnet) {
operateVnet(vnet, bw_remaining, schedule_wakeup,
it.second, m_out[vnet]);
m_in[vnet], m_out[vnet]);
}
} else {
for (auto it = m_in.rbegin(); it != m_in.rend(); ++it) {
int vnet = (*it).first;
for (int vnet = m_vnets-1; vnet >= 0; --vnet) {
operateVnet(vnet, bw_remaining, schedule_wakeup,
(*it).second, m_out[vnet]);
m_in[vnet], m_out[vnet]);
}
}

11
src/mem/ruby/network/simple/Throttle.hh
View File

@@ -62,8 +62,8 @@ class Throttle : public Consumer
std::string name()
{ return csprintf("Throttle-%i", m_sID); }
void addLinks(const std::map<int, MessageBuffer*>& in_vec,
const std::map<int, MessageBuffer*>& out_vec);
void addLinks(const std::vector<MessageBuffer*>& in_vec,
const std::vector<MessageBuffer*>& out_vec);
void wakeup();
// The average utilization (a fraction) since last clearStats()
@@ -92,9 +92,10 @@ class Throttle : public Consumer
Throttle(const Throttle& obj);
Throttle& operator=(const Throttle& obj);
std::map<int, MessageBuffer*> m_in;
std::map<int, MessageBuffer*> m_out;
std::map<int, int> m_units_remaining;
std::vector<MessageBuffer*> m_in;
std::vector<MessageBuffer*> m_out;
unsigned int m_vnets;
std::vector<int> m_units_remaining;
int m_sID;
NodeID m_node;