ruby: network: revert some of the changes from ad9c042dce54

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.

diff --git a/src/mem/ruby/network/Network.cc b/src/mem/ruby/network/Network.cc
index 2d9376b082417dc6503cd7294f81110cbfad2296..5f1fff1959cc6901499e33f365025abed7c71593 100644 (file)
--- a/src/mem/ruby/network/Network.cc
+++ b/src/mem/ruby/network/Network.cc
@@ -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;
         }
     }
 

diff --git a/src/mem/ruby/network/Network.hh b/src/mem/ruby/network/Network.hh
index d595ca2850e7db75be0868217498e319abfaa8e8..6b6258b2bdef6c1f58b881b4412e0e817f711e38 100644 (file)
--- a/src/mem/ruby/network/Network.hh
+++ b/src/mem/ruby/network/Network.hh
@@ -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;

diff --git a/src/mem/ruby/network/garnet/BaseGarnetNetwork.cc b/src/mem/ruby/network/garnet/BaseGarnetNetwork.cc
index 2aeddad37ae911da1d7ad70d5b0b0b1687d7bcdc..ed4679c6355ddf9d6519f073bfcf200d245a9c3b 100644 (file)
--- a/src/mem/ruby/network/garnet/BaseGarnetNetwork.cc
+++ b/src/mem/ruby/network/garnet/BaseGarnetNetwork.cc
@@ -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;
 }
 

diff --git a/src/mem/ruby/network/garnet/fixed-pipeline/NetworkInterface_d.cc b/src/mem/ruby/network/garnet/fixed-pipeline/NetworkInterface_d.cc
index 7384cc6a7296b914c747f79b4ce880afe69d1139..47ded231ca358e7296d6d6523ab4aafddaba3355 100644 (file)
--- a/src/mem/ruby/network/garnet/fixed-pipeline/NetworkInterface_d.cc
+++ b/src/mem/ruby/network/garnet/fixed-pipeline/NetworkInterface_d.cc
@@ -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;
         }

diff --git a/src/mem/ruby/network/garnet/fixed-pipeline/NetworkInterface_d.hh b/src/mem/ruby/network/garnet/fixed-pipeline/NetworkInterface_d.hh
index 2494d05d1c5c6c93ad9eadb523e4dc8067aba33f..0cb928d820827bdd76a3b187ddf5cf0ac7e6ffba 100644 (file)
--- a/src/mem/ruby/network/garnet/fixed-pipeline/NetworkInterface_d.hh
+++ b/src/mem/ruby/network/garnet/fixed-pipeline/NetworkInterface_d.hh
@@ -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);

diff --git a/src/mem/ruby/network/garnet/flexible-pipeline/NetworkInterface.cc b/src/mem/ruby/network/garnet/flexible-pipeline/NetworkInterface.cc
index 26d2423e86b3d33ae8aa4cfd8e97af65cb46c6e6..32066f0e1059673e6fb20f44175c2ea6783459c6 100644 (file)
--- a/src/mem/ruby/network/garnet/flexible-pipeline/NetworkInterface.cc
+++ b/src/mem/ruby/network/garnet/flexible-pipeline/NetworkInterface.cc
@@ -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;
         }

diff --git a/src/mem/ruby/network/garnet/flexible-pipeline/NetworkInterface.hh b/src/mem/ruby/network/garnet/flexible-pipeline/NetworkInterface.hh
index aa30bd758da6b26299c12a087d741f51a7ac3246..03cdf3dc6db26e58306fbd112defd12b1f3bf76b 100644 (file)
--- a/src/mem/ruby/network/garnet/flexible-pipeline/NetworkInterface.hh
+++ b/src/mem/ruby/network/garnet/flexible-pipeline/NetworkInterface.hh
@@ -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);

diff --git a/src/mem/ruby/network/simple/PerfectSwitch.cc b/src/mem/ruby/network/simple/PerfectSwitch.cc
index caf07b3cfc5684e3e06bdd63a7e8d905497116f7..86cafbe151178e91ff7b3cac0153798764db13af 100644 (file)
--- a/src/mem/ruby/network/simple/PerfectSwitch.cc
+++ b/src/mem/ruby/network/simple/PerfectSwitch.cc
@@ -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);

diff --git a/src/mem/ruby/network/simple/PerfectSwitch.hh b/src/mem/ruby/network/simple/PerfectSwitch.hh
index 161430bd142b50208e48fc3d7181e2e6614b51d4..f55281d54238d0f1aa26e12bce19060eb77378bb 100644 (file)
--- a/src/mem/ruby/network/simple/PerfectSwitch.hh
+++ b/src/mem/ruby/network/simple/PerfectSwitch.hh
@@ -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;

diff --git a/src/mem/ruby/network/simple/SimpleNetwork.cc b/src/mem/ruby/network/simple/SimpleNetwork.cc
index f51a0c891ac631e01c7dc12ff55817b93e12e381..074052cb932d9f26487ae57d28af3a4f0b13b7e1 100644 (file)
--- a/src/mem/ruby/network/simple/SimpleNetwork.cc
+++ b/src/mem/ruby/network/simple/SimpleNetwork.cc
@@ -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;
 }
 

diff --git a/src/mem/ruby/network/simple/Switch.cc b/src/mem/ruby/network/simple/Switch.cc
index e028de02ae4eb6e8c294569d6c8600ab96c4ba47..416a222bb5767fd4af216756bdfa92baef211082 100644 (file)
--- a/src/mem/ruby/network/simple/Switch.cc
+++ b/src/mem/ruby/network/simple/Switch.cc
@@ -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);

diff --git a/src/mem/ruby/network/simple/Switch.hh b/src/mem/ruby/network/simple/Switch.hh
index d4e5c5eba11f79ec5564c3a15feeac5702ba80de..3c11a5fa037da8b6e46058c53e4bdbab1c373d0e 100644 (file)
--- a/src/mem/ruby/network/simple/Switch.hh
+++ b/src/mem/ruby/network/simple/Switch.hh
@@ -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);
 

diff --git a/src/mem/ruby/network/simple/Throttle.cc b/src/mem/ruby/network/simple/Throttle.cc
index 91bad217bbfb32662f8bd70e5330bfe8a987145d..2da810edbcc202fa5ea86736b98820568b4b7da1 100644 (file)
--- a/src/mem/ruby/network/simple/Throttle.cc
+++ b/src/mem/ruby/network/simple/Throttle.cc
@@ -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;
-
-        auto jt = out_vec.find(vnet);
-        assert(jt != out_vec.end());
+    for (int vnet = 0; vnet < in_vec.size(); ++vnet) {
+        MessageBuffer *in_ptr = in_vec[vnet];
+        MessageBuffer *out_ptr = out_vec[vnet];
 
-        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]);
         }
     }
 

diff --git a/src/mem/ruby/network/simple/Throttle.hh b/src/mem/ruby/network/simple/Throttle.hh
index d978f14fd782fa5c6c9017a717698865e6b02a0a..797511702befaf7fa0be7e85f246969eb944e225 100644 (file)
--- a/src/mem/ruby/network/simple/Throttle.hh
+++ b/src/mem/ruby/network/simple/Throttle.hh
@@ -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;