ruby: reverts to changeset: bf82f1f7b040

12 files changed, 305 insertions, 166 deletions

diff --git a/src/mem/ruby/network/MessageBuffer.cc b/src/mem/ruby/network/MessageBuffer.cc
index e9c575028..a72d8509e 100644
--- a/src/mem/ruby/network/MessageBuffer.cc
+++ b/src/mem/ruby/network/MessageBuffer.cc
@@ -362,6 +362,32 @@ MessageBuffer::isReady() const
         (m_prio_heap.front()->getLastEnqueueTime() <= m_receiver->clockEdge()));
 }
 
+bool
+MessageBuffer::functionalRead(Packet *pkt)
+{
+    // Check the priority heap and read any messages that may
+    // correspond to the address in the packet.
+    for (unsigned int i = 0; i < m_prio_heap.size(); ++i) {
+        Message *msg = m_prio_heap[i].get();
+        if (msg->functionalRead(pkt)) return true;
+    }
+
+    // Read the messages in the stall queue that correspond
+    // to the address in the packet.
+    for (StallMsgMapType::iterator map_iter = m_stall_msg_map.begin();
+         map_iter != m_stall_msg_map.end();
+         ++map_iter) {
+
+        for (std::list<MsgPtr>::iterator it = (map_iter->second).begin();
+            it != (map_iter->second).end(); ++it) {
+
+            Message *msg = (*it).get();
+            if (msg->functionalRead(pkt)) return true;
+        }
+    }
+    return false;
+}
+
 uint32_t
 MessageBuffer::functionalWrite(Packet *pkt)
 {
diff --git a/src/mem/ruby/network/MessageBuffer.hh b/src/mem/ruby/network/MessageBuffer.hh
index 2625acabd..732b7ec6c 100644
--- a/src/mem/ruby/network/MessageBuffer.hh
+++ b/src/mem/ruby/network/MessageBuffer.hh
@@ -136,6 +136,11 @@ class MessageBuffer : public SimObject
     void setIncomingLink(int link_id) { m_input_link_id = link_id; }
     void setVnet(int net) { m_vnet_id = net; }
 
+    // Function for figuring out if any of the messages in the buffer can
+    // satisfy the read request for the address in the packet.
+    // Return value, if true, indicates that the request was fulfilled.
+    bool functionalRead(Packet *pkt);
+
     // Function for figuring out if any of the messages in the buffer need
     // to be updated with the data from the packet.
     // Return value indicates the number of messages that were updated.
@@ -179,7 +184,7 @@ class MessageBuffer : public SimObject
 
     int m_not_avail_count;  // count the # of times I didn't have N
                             // slots available
-    uint64_t m_msg_counter;
+    uint64 m_msg_counter;
     int m_priority_rank;
     const bool m_strict_fifo;
     const bool m_randomization;
diff --git a/src/mem/ruby/network/garnet/flexible-pipeline/NetworkInterface.cc b/src/mem/ruby/network/garnet/flexible-pipeline/NetworkInterface.cc
index f72cea5a8..d834ea1a3 100644
--- a/src/mem/ruby/network/garnet/flexible-pipeline/NetworkInterface.cc
+++ b/src/mem/ruby/network/garnet/flexible-pipeline/NetworkInterface.cc
@@ -281,7 +281,7 @@ NetworkInterface::wakeup()
 
         int vnet = t_flit->get_vnet();
         m_net_ptr->increment_received_flits(vnet);
-        Cycles network_delay = curCycle() - t_flit->get_creation_time();
+        Cycles network_delay = curCycle() - t_flit->get_enqueue_time();
         Cycles queueing_delay = t_flit->get_delay();
 
         m_net_ptr->increment_network_latency(network_delay, vnet);
diff --git a/src/mem/ruby/network/garnet/flexible-pipeline/flit.cc b/src/mem/ruby/network/garnet/flexible-pipeline/flit.cc
index aaf19b3b5..7cf68560f 100644
--- a/src/mem/ruby/network/garnet/flexible-pipeline/flit.cc
+++ b/src/mem/ruby/network/garnet/flexible-pipeline/flit.cc
@@ -31,10 +31,14 @@
 #include "mem/ruby/network/garnet/flexible-pipeline/flit.hh"
 
 flit::flit(int id, int  vc, int vnet, int size, MsgPtr msg_ptr, Cycles curTime)
-    : m_id(id), m_vnet(vnet), m_vc(vc), m_size(size), m_creation_time(curTime)
 {
+    m_size = size;
     m_msg_ptr = msg_ptr;
+    m_enqueue_time = curTime;
     m_time = curTime;
+    m_id = id;
+    m_vnet = vnet;
+    m_vc = vc;
 
     if (size == 1) {
         m_type = HEAD_TAIL_;
@@ -48,6 +52,78 @@ flit::flit(int id, int  vc, int vnet, int size, MsgPtr msg_ptr, Cycles curTime)
         m_type = BODY_;
 }
 
+int
+flit::get_size()
+{
+    return m_size;
+}
+
+int
+flit::get_id()
+{
+    return m_id;
+}
+
+Cycles
+flit::get_time()
+{
+    return m_time;
+}
+
+Cycles
+flit::get_enqueue_time()
+{
+    return m_enqueue_time;
+}
+
+void
+flit::set_time(Cycles time)
+{
+    m_time = time;
+}
+
+int
+flit::get_vnet()
+{
+    return m_vnet;
+}
+
+int
+flit::get_vc()
+{
+    return m_vc;
+}
+
+void
+flit::set_vc(int vc)
+{
+    m_vc = vc;
+}
+
+MsgPtr&
+flit::get_msg_ptr()
+{
+    return m_msg_ptr;
+}
+
+flit_type
+flit::get_type()
+{
+    return m_type;
+}
+
+void
+flit::set_delay(Cycles delay)
+{
+    src_delay = delay;
+}
+
+Cycles
+flit::get_delay()
+{
+    return src_delay;
+}
+
 void
 flit::print(std::ostream& out) const
 {
@@ -56,7 +132,7 @@ flit::print(std::ostream& out) const
     out << "Type=" << m_type << " ";
     out << "Vnet=" << m_vnet << " ";
     out << "VC=" << m_vc << " ";
-    out << "Creation Time=" << m_creation_time << " ";
+    out << "Enqueue Time=" << m_enqueue_time << " ";
     out << "]";
 }
 
diff --git a/src/mem/ruby/network/garnet/flexible-pipeline/flit.hh b/src/mem/ruby/network/garnet/flexible-pipeline/flit.hh
index 4049a9212..ff4afbc08 100644
--- a/src/mem/ruby/network/garnet/flexible-pipeline/flit.hh
+++ b/src/mem/ruby/network/garnet/flexible-pipeline/flit.hh
@@ -43,18 +43,18 @@ class flit
   public:
     flit(int id, int vc, int vnet, int size, MsgPtr msg_ptr, Cycles curTime);
 
-    int get_size() const { return m_size; }
-    int get_id() const { return m_id; }
-    Cycles get_time() const { return m_time; }
-    Cycles get_creation_time() const { return m_creation_time; }
-    void set_time(Cycles time) { m_time = time; }
-    int get_vnet() const { return m_vnet; }
-    int get_vc() const { return m_vc; }
-    void set_vc(int vc) { m_vc = vc; }
-    MsgPtr& get_msg_ptr() { return m_msg_ptr; }
-    flit_type get_type() const { return m_type; }
-    void set_delay(Cycles delay) { src_delay = delay; }
-    Cycles get_delay() const { return src_delay; }
+    int get_size();
+    int get_id();
+    Cycles get_time();
+    Cycles get_enqueue_time();
+    void set_time(Cycles time);
+    int get_vnet();
+    int get_vc();
+    void set_vc(int vc);
+    MsgPtr& get_msg_ptr();
+    flit_type get_type();
+    void set_delay(Cycles delay);
+    Cycles get_delay();
     void print(std::ostream& out) const;
 
     static bool
@@ -71,12 +71,11 @@ class flit
     bool functionalWrite(Packet *pkt);
 
   private:
-    const int m_id;
-    const int m_vnet;
+    int m_id;
+    int m_vnet;
     int m_vc;
-    const int m_size;
-    const Cycles m_creation_time;
-    Cycles m_time;
+    int m_size;
+    Cycles m_enqueue_time, m_time;
     flit_type m_type;
     MsgPtr m_msg_ptr;
     Cycles src_delay;
diff --git a/src/mem/ruby/network/simple/PerfectSwitch.cc b/src/mem/ruby/network/simple/PerfectSwitch.cc
index 697357ccb..de038d211 100644
--- a/src/mem/ruby/network/simple/PerfectSwitch.cc
+++ b/src/mem/ruby/network/simple/PerfectSwitch.cc
@@ -49,8 +49,9 @@ operator<(const LinkOrder& l1, const LinkOrder& l2)
 }
 
 PerfectSwitch::PerfectSwitch(SwitchID sid, Switch *sw, uint32_t virt_nets)
-    : Consumer(sw), m_switch_id(sid), m_switch(sw)
+    : Consumer(sw)
 {
+    m_switch_id = sid;
     m_round_robin_start = 0;
     m_wakeups_wo_switch = 0;
     m_virtual_networks = virt_nets;
@@ -103,6 +104,9 @@ PerfectSwitch::~PerfectSwitch()
 void
 PerfectSwitch::operateVnet(int vnet)
 {
+    MsgPtr msg_ptr;
+    Message *net_msg_ptr = NULL;
+
     // This is for round-robin scheduling
     int incoming = m_round_robin_start;
     m_round_robin_start++;
@@ -119,6 +123,10 @@ PerfectSwitch::operateVnet(int vnet)
                 incoming = 0;
             }
 
+            // temporary vectors to store the routing results
+            vector<LinkID> output_links;
+            vector<NetDest> output_link_destinations;
+
             // Is there a message waiting?
             if (m_in[incoming].size() <= vnet) {
                 continue;
@@ -129,151 +137,138 @@ PerfectSwitch::operateVnet(int vnet)
                 continue;
             }
 
-            operateMessageBuffer(buffer, incoming, vnet);
-        }
-    }
-}
-
-void
-PerfectSwitch::operateMessageBuffer(MessageBuffer *buffer, int incoming,
-                                    int vnet)
-{
-    MsgPtr msg_ptr;
-    Message *net_msg_ptr = NULL;
-
-    // temporary vectors to store the routing results
-    vector<LinkID> output_links;
-    vector<NetDest> output_link_destinations;
-
-    while (buffer->isReady()) {
-        DPRINTF(RubyNetwork, "incoming: %d\n", incoming);
-
-        // Peek at message
-        msg_ptr = buffer->peekMsgPtr();
-        net_msg_ptr = msg_ptr.get();
-        DPRINTF(RubyNetwork, "Message: %s\n", (*net_msg_ptr));
-
-        output_links.clear();
-        output_link_destinations.clear();
-        NetDest msg_dsts = net_msg_ptr->getDestination();
-
-        // Unfortunately, the token-protocol sends some
-        // zero-destination messages, so this assert isn't valid
-        // assert(msg_dsts.count() > 0);
-
-        assert(m_link_order.size() == m_routing_table.size());
-        assert(m_link_order.size() == m_out.size());
-
-        if (m_network_ptr->getAdaptiveRouting()) {
-            if (m_network_ptr->isVNetOrdered(vnet)) {
-                // Don't adaptively route
-                for (int out = 0; out < m_out.size(); out++) {
-                    m_link_order[out].m_link = out;
-                    m_link_order[out].m_value = 0;
-                }
-            } else {
-                // Find how clogged each link is
-                for (int out = 0; out < m_out.size(); out++) {
-                    int out_queue_length = 0;
-                    for (int v = 0; v < m_virtual_networks; v++) {
-                        out_queue_length += m_out[out][v]->getSize();
+            while (buffer->isReady()) {
+                DPRINTF(RubyNetwork, "incoming: %d\n", incoming);
+
+                // Peek at message
+                msg_ptr = buffer->peekMsgPtr();
+                net_msg_ptr = msg_ptr.get();
+                DPRINTF(RubyNetwork, "Message: %s\n", (*net_msg_ptr));
+
+                output_links.clear();
+                output_link_destinations.clear();
+                NetDest msg_dsts = net_msg_ptr->getDestination();
+
+                // Unfortunately, the token-protocol sends some
+                // zero-destination messages, so this assert isn't valid
+                // assert(msg_dsts.count() > 0);
+
+                assert(m_link_order.size() == m_routing_table.size());
+                assert(m_link_order.size() == m_out.size());
+
+                if (m_network_ptr->getAdaptiveRouting()) {
+                    if (m_network_ptr->isVNetOrdered(vnet)) {
+                        // Don't adaptively route
+                        for (int out = 0; out < m_out.size(); out++) {
+                            m_link_order[out].m_link = out;
+                            m_link_order[out].m_value = 0;
+                        }
+                    } else {
+                        // Find how clogged each link is
+                        for (int out = 0; out < m_out.size(); out++) {
+                            int out_queue_length = 0;
+                            for (int v = 0; v < m_virtual_networks; v++) {
+                                out_queue_length += m_out[out][v]->getSize();
+                            }
+                            int value =
+                                (out_queue_length << 8) |
+                                random_mt.random(0, 0xff);
+                            m_link_order[out].m_link = out;
+                            m_link_order[out].m_value = value;
+                        }
+
+                        // Look at the most empty link first
+                        sort(m_link_order.begin(), m_link_order.end());
                     }
-                    int value =
-                        (out_queue_length << 8) |
-                        random_mt.random(0, 0xff);
-                    m_link_order[out].m_link = out;
-                    m_link_order[out].m_value = value;
                 }
 
-                // Look at the most empty link first
-                sort(m_link_order.begin(), m_link_order.end());
-            }
-        }
+                for (int i = 0; i < m_routing_table.size(); i++) {
+                    // pick the next link to look at
+                    int link = m_link_order[i].m_link;
+                    NetDest dst = m_routing_table[link];
+                    DPRINTF(RubyNetwork, "dst: %s\n", dst);
 
-        for (int i = 0; i < m_routing_table.size(); i++) {
-            // pick the next link to look at
-            int link = m_link_order[i].m_link;
-            NetDest dst = m_routing_table[link];
-            DPRINTF(RubyNetwork, "dst: %s\n", dst);
+                    if (!msg_dsts.intersectionIsNotEmpty(dst))
+                        continue;
 
-            if (!msg_dsts.intersectionIsNotEmpty(dst))
-                continue;
+                    // Remember what link we're using
+                    output_links.push_back(link);
 
-            // Remember what link we're using
-            output_links.push_back(link);
+                    // Need to remember which destinations need this message in
+                    // another vector.  This Set is the intersection of the
+                    // routing_table entry and the current destination set.  The
+                    // intersection must not be empty, since we are inside "if"
+                    output_link_destinations.push_back(msg_dsts.AND(dst));
 
-            // Need to remember which destinations need this message in
-            // another vector.  This Set is the intersection of the
-            // routing_table entry and the current destination set.  The
-            // intersection must not be empty, since we are inside "if"
-            output_link_destinations.push_back(msg_dsts.AND(dst));
-
-            // Next, we update the msg_destination not to include
-            // those nodes that were already handled by this link
-            msg_dsts.removeNetDest(dst);
-        }
+                    // Next, we update the msg_destination not to include
+                    // those nodes that were already handled by this link
+                    msg_dsts.removeNetDest(dst);
+                }
 
-        assert(msg_dsts.count() == 0);
+                assert(msg_dsts.count() == 0);
 
-        // Check for resources - for all outgoing queues
-        bool enough = true;
-        for (int i = 0; i < output_links.size(); i++) {
-            int outgoing = output_links[i];
+                // Check for resources - for all outgoing queues
+                bool enough = true;
+                for (int i = 0; i < output_links.size(); i++) {
+                    int outgoing = output_links[i];
 
-            if (!m_out[outgoing][vnet]->areNSlotsAvailable(1))
-                enough = false;
+                    if (!m_out[outgoing][vnet]->areNSlotsAvailable(1))
+                        enough = false;
 
-            DPRINTF(RubyNetwork, "Checking if node is blocked ..."
-                    "outgoing: %d, vnet: %d, enough: %d\n",
-                    outgoing, vnet, enough);
-        }
+                    DPRINTF(RubyNetwork, "Checking if node is blocked ..."
+                            "outgoing: %d, vnet: %d, enough: %d\n",
+                            outgoing, vnet, enough);
+                }
 
-        // There were not enough resources
-        if (!enough) {
-            scheduleEvent(Cycles(1));
-            DPRINTF(RubyNetwork, "Can't deliver message since a node "
-                    "is blocked\n");
-            DPRINTF(RubyNetwork, "Message: %s\n", (*net_msg_ptr));
-            break; // go to next incoming port
-        }
+                // There were not enough resources
+                if (!enough) {
+                    scheduleEvent(Cycles(1));
+                    DPRINTF(RubyNetwork, "Can't deliver message since a node "
+                            "is blocked\n");
+                    DPRINTF(RubyNetwork, "Message: %s\n", (*net_msg_ptr));
+                    break; // go to next incoming port
+                }
 
-        MsgPtr unmodified_msg_ptr;
+                MsgPtr unmodified_msg_ptr;
 
-        if (output_links.size() > 1) {
-            // If we are sending this message down more than one link
-            // (size>1), we need to make a copy of the message so each
-            // branch can have a different internal destination we need
-            // to create an unmodified MsgPtr because the MessageBuffer
-            // enqueue func will modify the message
+                if (output_links.size() > 1) {
+                    // If we are sending this message down more than one link
+                    // (size>1), we need to make a copy of the message so each
+                    // branch can have a different internal destination we need
+                    // to create an unmodified MsgPtr because the MessageBuffer
+                    // enqueue func will modify the message
 
-            // This magic line creates a private copy of the message
-            unmodified_msg_ptr = msg_ptr->clone();
-        }
+                    // This magic line creates a private copy of the message
+                    unmodified_msg_ptr = msg_ptr->clone();
+                }
 
-        // Dequeue msg
-        buffer->dequeue();
-        m_pending_message_count[vnet]--;
+                // Dequeue msg
+                buffer->dequeue();
+                m_pending_message_count[vnet]--;
 
-        // Enqueue it - for all outgoing queues
-        for (int i=0; i<output_links.size(); i++) {
-            int outgoing = output_links[i];
+                // Enqueue it - for all outgoing queues
+                for (int i=0; i<output_links.size(); i++) {
+                    int outgoing = output_links[i];
 
-            if (i > 0) {
-                // create a private copy of the unmodified message
-                msg_ptr = unmodified_msg_ptr->clone();
-            }
+                    if (i > 0) {
+                        // create a private copy of the unmodified message
+                        msg_ptr = unmodified_msg_ptr->clone();
+                    }
 
-            // Change the internal destination set of the message so it
-            // knows which destinations this link is responsible for.
-            net_msg_ptr = msg_ptr.get();
-            net_msg_ptr->getDestination() = output_link_destinations[i];
+                    // Change the internal destination set of the message so it
+                    // knows which destinations this link is responsible for.
+                    net_msg_ptr = msg_ptr.get();
+                    net_msg_ptr->getDestination() =
+                        output_link_destinations[i];
 
-            // Enqeue msg
-            DPRINTF(RubyNetwork, "Enqueuing net msg from "
-                    "inport[%d][%d] to outport [%d][%d].\n",
-                    incoming, vnet, outgoing, vnet);
+                    // Enqeue msg
+                    DPRINTF(RubyNetwork, "Enqueuing net msg from "
+                            "inport[%d][%d] to outport [%d][%d].\n",
+                            incoming, vnet, outgoing, vnet);
 
-            m_out[outgoing][vnet]->enqueue(msg_ptr);
+                    m_out[outgoing][vnet]->enqueue(msg_ptr);
+                }
+            }
         }
     }
 }
diff --git a/src/mem/ruby/network/simple/PerfectSwitch.hh b/src/mem/ruby/network/simple/PerfectSwitch.hh
index 1cc986964..f55281d54 100644
--- a/src/mem/ruby/network/simple/PerfectSwitch.hh
+++ b/src/mem/ruby/network/simple/PerfectSwitch.hh
@@ -85,10 +85,8 @@ class PerfectSwitch : public Consumer
     PerfectSwitch& operator=(const PerfectSwitch& obj);
 
     void operateVnet(int vnet);
-    void operateMessageBuffer(MessageBuffer *b, int incoming, int vnet);
 
-    const SwitchID m_switch_id;
-    Switch * const m_switch;
+    SwitchID m_switch_id;
 
     // vector of queues from the components
     std::vector<std::vector<MessageBuffer*> > m_in;
diff --git a/src/mem/ruby/network/simple/SimpleNetwork.cc b/src/mem/ruby/network/simple/SimpleNetwork.cc
index 09daa7960..5b7d7ebad 100644
--- a/src/mem/ruby/network/simple/SimpleNetwork.cc
+++ b/src/mem/ruby/network/simple/SimpleNetwork.cc
@@ -38,15 +38,23 @@
 #include "mem/ruby/network/simple/Switch.hh"
 #include "mem/ruby/network/simple/Throttle.hh"
 #include "mem/ruby/profiler/Profiler.hh"
+#include "mem/ruby/system/System.hh"
 
 using namespace std;
 using m5::stl_helpers::deletePointers;
 
 SimpleNetwork::SimpleNetwork(const Params *p)
-    : Network(p), m_buffer_size(p->buffer_size),
-      m_endpoint_bandwidth(p->endpoint_bandwidth),
-      m_adaptive_routing(p->adaptive_routing)
+    : Network(p)
 {
+    m_buffer_size = p->buffer_size;
+    m_endpoint_bandwidth = p->endpoint_bandwidth;
+    m_adaptive_routing = p->adaptive_routing;
+
+    // Note: the parent Network Object constructor is called before the
+    // SimpleNetwork child constructor.  Therefore, the member variables
+    // used below should already be initialized.
+    m_endpoint_switches.resize(m_nodes);
+
     // record the routers
     for (vector<BasicRouter*>::const_iterator i = p->routers.begin();
          i != p->routers.end(); ++i) {
@@ -91,6 +99,8 @@ SimpleNetwork::makeOutLink(SwitchID src, NodeID dest, BasicLink* link,
     m_switches[src]->addOutPort(m_fromNetQueues[dest], routing_table_entry,
                                 simple_link->m_latency,
                                 simple_link->m_bw_multiplier);
+
+    m_endpoint_switches[dest] = m_switches[src];
 }
 
 // From an endpoint node to a switch
@@ -223,6 +233,12 @@ SimpleNetwork::functionalRead(Packet *pkt)
         }
     }
 
+    for (unsigned int i = 0; i < m_int_link_buffers.size(); ++i) {
+        if (m_int_link_buffers[i]->functionalRead(pkt)) {
+            return true;
+        }
+    }
+
     return false;
 }
 
diff --git a/src/mem/ruby/network/simple/SimpleNetwork.hh b/src/mem/ruby/network/simple/SimpleNetwork.hh
index efb342e6e..fe0c1838b 100644
--- a/src/mem/ruby/network/simple/SimpleNetwork.hh
+++ b/src/mem/ruby/network/simple/SimpleNetwork.hh
@@ -95,9 +95,11 @@ class SimpleNetwork : public Network
     std::vector<Switch*> m_switches;
     std::vector<MessageBuffer*> m_int_link_buffers;
     int m_num_connected_buffers;
-    const int m_buffer_size;
-    const int m_endpoint_bandwidth;
-    const bool m_adaptive_routing;
+    std::vector<Switch*> m_endpoint_switches;
+
+    int m_buffer_size;
+    int m_endpoint_bandwidth;
+    bool m_adaptive_routing;    
 
     //Statistical variables
     Stats::Formula m_msg_counts[MessageSizeType_NUM];
diff --git a/src/mem/ruby/network/simple/Switch.cc b/src/mem/ruby/network/simple/Switch.cc
index e5988e505..b9d0b8010 100644
--- a/src/mem/ruby/network/simple/Switch.cc
+++ b/src/mem/ruby/network/simple/Switch.cc
@@ -184,6 +184,12 @@ Switch::print(std::ostream& out) const
 bool
 Switch::functionalRead(Packet *pkt)
 {
+    // Access the buffers in the switch for performing a functional read
+    for (unsigned int i = 0; i < m_port_buffers.size(); ++i) {
+        if (m_port_buffers[i]->functionalRead(pkt)) {
+            return true;
+        }
+    }
     return false;
 }
 
diff --git a/src/mem/ruby/network/simple/Throttle.cc b/src/mem/ruby/network/simple/Throttle.cc
index c97531e58..785e09aa2 100644
--- a/src/mem/ruby/network/simple/Throttle.cc
+++ b/src/mem/ruby/network/simple/Throttle.cc
@@ -31,7 +31,6 @@
 #include "base/cast.hh"
 #include "base/cprintf.hh"
 #include "debug/RubyNetwork.hh"
-#include "mem/ruby/network/simple/Switch.hh"
 #include "mem/ruby/network/simple/Throttle.hh"
 #include "mem/ruby/network/MessageBuffer.hh"
 #include "mem/ruby/network/Network.hh"
@@ -49,10 +48,27 @@ static int network_message_to_size(Message* net_msg_ptr);
 
 Throttle::Throttle(int sID, RubySystem *rs, NodeID node, Cycles link_latency,
                    int link_bandwidth_multiplier, int endpoint_bandwidth,
-                   Switch *em)
-    : Consumer(em), m_switch_id(sID), m_switch(em), m_node(node),
-      m_ruby_system(rs)
+                   ClockedObject *em)
+    : Consumer(em), m_ruby_system(rs)
 {
+    init(node, link_latency, link_bandwidth_multiplier, endpoint_bandwidth);
+    m_sID = sID;
+}
+
+Throttle::Throttle(RubySystem *rs, NodeID node, Cycles link_latency,
+                   int link_bandwidth_multiplier, int endpoint_bandwidth,
+                   ClockedObject *em)
+    : Consumer(em), m_ruby_system(rs)
+{
+    init(node, link_latency, link_bandwidth_multiplier, endpoint_bandwidth);
+    m_sID = 0;
+}
+
+void
+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);
@@ -82,7 +98,7 @@ Throttle::addLinks(const vector<MessageBuffer*>& in_vec,
 
         // Set consumer and description
         in_ptr->setConsumer(this);
-        string desc = "[Queue to Throttle " + to_string(m_switch_id) + " " +
+        string desc = "[Queue to Throttle " + to_string(m_sID) + " " +
             to_string(m_node) + "]";
     }
 }
diff --git a/src/mem/ruby/network/simple/Throttle.hh b/src/mem/ruby/network/simple/Throttle.hh
index 405593bb1..85bf9691a 100644
--- a/src/mem/ruby/network/simple/Throttle.hh
+++ b/src/mem/ruby/network/simple/Throttle.hh
@@ -47,18 +47,20 @@
 #include "mem/ruby/system/System.hh"
 
 class MessageBuffer;
-class Switch;
 
 class Throttle : public Consumer
 {
   public:
     Throttle(int sID, RubySystem *rs, NodeID node, Cycles link_latency,
              int link_bandwidth_multiplier, int endpoint_bandwidth,
-             Switch *em);
+             ClockedObject *em);
+    Throttle(RubySystem *rs, NodeID node, Cycles link_latency,
+             int link_bandwidth_multiplier, int endpoint_bandwidth,
+             ClockedObject *em);
     ~Throttle() {}
 
     std::string name()
-    { return csprintf("Throttle-%i", m_switch_id); }
+    { return csprintf("Throttle-%i", m_sID); }
 
     void addLinks(const std::vector<MessageBuffer*>& in_vec,
                   const std::vector<MessageBuffer*>& out_vec);
@@ -95,10 +97,8 @@ class Throttle : public Consumer
     unsigned int m_vnets;
     std::vector<int> m_units_remaining;
 
-    const int m_switch_id;
-    Switch *m_switch;
+    int m_sID;
     NodeID m_node;
-
     int m_link_bandwidth_multiplier;
     Cycles m_link_latency;
     int m_wakeups_wo_switch;