1 files changed, 28 insertions, 29 deletions

diff --git a/src/mem/ruby/network/garnet/flexible-pipeline/NetworkInterface.cc b/src/mem/ruby/network/garnet/flexible-pipeline/NetworkInterface.cc
index fb918f95d..ba32abd44 100644
--- a/src/mem/ruby/network/garnet/flexible-pipeline/NetworkInterface.cc
+++ b/src/mem/ruby/network/garnet/flexible-pipeline/NetworkInterface.cc
@@ -42,14 +42,12 @@
 using namespace std;
 using m5::stl_helpers::deletePointers;
 
-NetworkInterface::NetworkInterface(int id, int virtual_networks,
-                                   GarnetNetwork *network_ptr)
-    : FlexibleConsumer(network_ptr)
+NetworkInterface::NetworkInterface(const Params *p)
+    : ClockedObject(p), FlexibleConsumer(this)
 {
-    m_id = id;
-    m_net_ptr = network_ptr;
-    m_virtual_networks  = virtual_networks;
-    m_vc_per_vnet = m_net_ptr->getVCsPerVnet();
+    m_id = p->id;
+    m_virtual_networks  = p->virt_nets;
+    m_vc_per_vnet = p->vcs_per_vnet;
     m_num_vcs = m_vc_per_vnet*m_virtual_networks;
 
     m_vc_round_robin = 0;
@@ -105,9 +103,8 @@ NetworkInterface::addNode(vector<MessageBuffer*>& in,
     // protocol injects messages into the NI
     for (int j = 0; j < m_virtual_networks; j++) {
         inNode_ptr[j]->setConsumer(this);
-        inNode_ptr[j]->setReceiver(m_net_ptr);
-
-        outNode_ptr[j]->setSender(m_net_ptr);
+        inNode_ptr[j]->setReceiver(this);
+        outNode_ptr[j]->setSender(this);
     }
 }
 
@@ -169,20 +166,18 @@ NetworkInterface::flitisizeMessage(MsgPtr msg_ptr, int vnet)
         for (int i = 0; i < num_flits; i++) {
             m_net_ptr->increment_injected_flits(vnet);
             flit *fl = new flit(i, vc, vnet, num_flits, new_msg_ptr,
-                                m_net_ptr->curCycle());
-            fl->set_delay(m_net_ptr->curCycle() -
-                          m_net_ptr->ticksToCycles(msg_ptr->getTime()));
+                                curCycle());
+            fl->set_delay(curCycle() - ticksToCycles(msg_ptr->getTime()));
             m_ni_buffers[vc]->insert(fl);
         }
 
-        m_out_vc_state[vc]->setState(VC_AB_, m_net_ptr->curCycle());
+        m_out_vc_state[vc]->setState(VC_AB_, curCycle());
 
         // setting an output vc request for the next hop.
         // This flit will be ready to traverse the link and into the next hop
         // only when an output vc is acquired at the next hop
-        outNetLink->request_vc_link(vc,
-                                    new_net_msg_ptr->getInternalDestination(),
-                                    m_net_ptr->curCycle());
+        outNetLink->request_vc_link(
+                vc, new_net_msg_ptr->getInternalDestination(), curCycle());
     }
 
     return true ;
@@ -224,8 +219,8 @@ NetworkInterface::calculateVC(int vnet)
         if (m_vc_allocator[vnet] == vc_per_vnet)
             m_vc_allocator[vnet] = 0;
 
-        if (m_out_vc_state[(vnet*m_vc_per_vnet) + delta]->isInState(IDLE_,
-            m_net_ptr->curCycle())) {
+        if (m_out_vc_state[(vnet*m_vc_per_vnet) + delta]->
+                isInState(IDLE_, curCycle())) {
             return ((vnet*m_vc_per_vnet) + delta);
         }
     }
@@ -269,20 +264,19 @@ NetworkInterface::wakeup()
         flit *t_flit = inNetLink->consumeLink();
         if (t_flit->get_type() == TAIL_ || t_flit->get_type() == HEAD_TAIL_) {
             DPRINTF(RubyNetwork, "m_id: %d, Message delivered at time: %lld\n",
-                    m_id, m_net_ptr->curCycle());
+                    m_id, curCycle());
 
             outNode_ptr[t_flit->get_vnet()]->enqueue(
                 t_flit->get_msg_ptr(), Cycles(1));
 
             // signal the upstream router that this vc can be freed now
             inNetLink->release_vc_link(t_flit->get_vc(),
-                m_net_ptr->curCycle() + Cycles(1));
+                    curCycle() + Cycles(1));
         }
 
         int vnet = t_flit->get_vnet();
         m_net_ptr->increment_received_flits(vnet);
-        Cycles network_delay = m_net_ptr->curCycle() -
-                               t_flit->get_enqueue_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);
@@ -309,19 +303,18 @@ NetworkInterface::scheduleOutputLink()
         vc++;
         if (vc == m_num_vcs)
             vc = 0;
-        if (m_ni_buffers[vc]->isReady(m_net_ptr->curCycle())) {
-            if (m_out_vc_state[vc]->isInState(ACTIVE_,
-               m_net_ptr->curCycle()) &&
+        if (m_ni_buffers[vc]->isReady(curCycle())) {
+            if (m_out_vc_state[vc]->isInState(ACTIVE_, curCycle()) &&
                outNetLink->isBufferNotFull_link(vc)) {  // buffer backpressure
 
                 // Just removing the flit
                 flit *t_flit = m_ni_buffers[vc]->getTopFlit();
-                t_flit->set_time(m_net_ptr->curCycle() + Cycles(1));
+                t_flit->set_time(curCycle() + Cycles(1));
                 outSrcQueue->insert(t_flit);
 
                 // schedule the out link
                 outNetLink->
-                    scheduleEventAbsolute(m_net_ptr->clockEdge(Cycles(1)));
+                    scheduleEventAbsolute(clockEdge(Cycles(1)));
                 return;
             }
         }
@@ -338,7 +331,7 @@ NetworkInterface::checkReschedule()
         }
     }
     for (int vc = 0; vc < m_num_vcs; vc++) {
-        if (m_ni_buffers[vc]->isReadyForNext(m_net_ptr->curCycle())) {
+        if (m_ni_buffers[vc]->isReadyForNext(curCycle())) {
             scheduleEvent(Cycles(1));
             return;
         }
@@ -380,3 +373,9 @@ NetworkInterface::print(std::ostream& out) const
 {
     out << "[Network Interface]";
 }
+
+NetworkInterface *
+GarnetNetworkInterfaceParams::create()
+{
+    return new NetworkInterface(this);
+}