Ruby: remove reference to g_system_ptr from class Message

This patch was initiated so as to remove reference to g_system_ptr,
the pointer to Ruby System that is used for getting the current time.
That simple change actual requires changing a lot many things in slicc and
garnet. All these changes are related to how time is handled.

In most of the places, g_system_ptr has been replaced by another clock
object. The changes have been done under the assumption that all the
components in the memory system are on the same clock frequency, but the
actual clocks might be distributed.

8 files changed, 52 insertions, 63 deletions

diff --git a/src/mem/ruby/network/garnet/flexible-pipeline/GarnetNetwork.cc b/src/mem/ruby/network/garnet/flexible-pipeline/GarnetNetwork.cc
index 9916f4ba5..a60d23457 100644
--- a/src/mem/ruby/network/garnet/flexible-pipeline/GarnetNetwork.cc
+++ b/src/mem/ruby/network/garnet/flexible-pipeline/GarnetNetwork.cc
@@ -255,7 +255,7 @@ GarnetNetwork::printLinkStats(ostream& out) const
     for (int i = 0; i < m_link_ptr_vector.size(); i++) {
         average_link_utilization +=
             (double(m_link_ptr_vector[i]->getLinkUtilization())) /
-            (double(g_system_ptr->getTime()-m_ruby_start));
+            (double(curCycle() - m_ruby_start));
 
         vector<int> vc_load = m_link_ptr_vector[i]->getVcLoad();
         for (int j = 0; j < vc_load.size(); j++) {
@@ -273,8 +273,8 @@ GarnetNetwork::printLinkStats(ostream& out) const
         if (!m_in_use[i/m_vcs_per_vnet])
             continue;
 
-        average_vc_load[i] = (double(average_vc_load[i]) /
-            (double(g_system_ptr->getTime()) - m_ruby_start));
+        average_vc_load[i] = double(average_vc_load[i]) /
+            (double(curCycle() - m_ruby_start));
         out << "Average VC Load [" << i << "] = " << average_vc_load[i]
             << " flits/cycle " << endl;
     }
diff --git a/src/mem/ruby/network/garnet/flexible-pipeline/NetworkInterface.cc b/src/mem/ruby/network/garnet/flexible-pipeline/NetworkInterface.cc
index 9e4c1ef9a..7267da36d 100644
--- a/src/mem/ruby/network/garnet/flexible-pipeline/NetworkInterface.cc
+++ b/src/mem/ruby/network/garnet/flexible-pipeline/NetworkInterface.cc
@@ -68,7 +68,7 @@ NetworkInterface::NetworkInterface(int id, int virtual_networks,
 
     for (int i = 0; i < m_num_vcs; i++) {
         m_out_vc_state.push_back(new OutVcState(i));
-        m_out_vc_state[i]->setState(IDLE_, g_system_ptr->getTime());
+        m_out_vc_state[i]->setState(IDLE_, m_net_ptr->curCycle());
     }
 }
 
@@ -167,19 +167,20 @@ 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);
-            fl->set_delay(g_system_ptr->getTime() - msg_ptr->getTime());
+            flit *fl = new flit(i, vc, vnet, num_flits, new_msg_ptr,
+                                m_net_ptr->curCycle());
+            fl->set_delay(m_net_ptr->curCycle() - msg_ptr->getTime());
             m_ni_buffers[vc]->insert(fl);
         }
 
-        m_out_vc_state[vc]->setState(VC_AB_, g_system_ptr->getTime());
+        m_out_vc_state[vc]->setState(VC_AB_, m_net_ptr->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(),
-                                    g_system_ptr->getTime());
+                                    m_net_ptr->curCycle());
     }
 
     return true ;
@@ -222,7 +223,7 @@ NetworkInterface::calculateVC(int vnet)
             m_vc_allocator[vnet] = 0;
 
         if (m_out_vc_state[(vnet*m_vc_per_vnet) + delta]->isInState(IDLE_,
-            g_system_ptr->getTime())) {
+            m_net_ptr->curCycle())) {
             return ((vnet*m_vc_per_vnet) + delta);
         }
     }
@@ -266,18 +267,18 @@ 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, g_system_ptr->getTime());
+                    m_id, m_net_ptr->curCycle());
 
             outNode_ptr[t_flit->get_vnet()]->enqueue(
                 t_flit->get_msg_ptr(), 1);
 
             // signal the upstream router that this vc can be freed now
             inNetLink->release_vc_link(t_flit->get_vc(),
-                g_system_ptr->getTime() + 1);
+                m_net_ptr->curCycle() + 1);
         }
         int vnet = t_flit->get_vnet();
         m_net_ptr->increment_received_flits(vnet);
-        int network_delay = g_system_ptr->getTime() -
+        int network_delay = m_net_ptr->curCycle() -
                             t_flit->get_enqueue_time();
         int queueing_delay = t_flit->get_delay();
         m_net_ptr->increment_network_latency(network_delay, vnet);
@@ -304,14 +305,14 @@ NetworkInterface::scheduleOutputLink()
         vc++;
         if (vc == m_num_vcs)
             vc = 0;
-        if (m_ni_buffers[vc]->isReady()) {
+        if (m_ni_buffers[vc]->isReady(m_net_ptr->curCycle())) {
             if (m_out_vc_state[vc]->isInState(ACTIVE_,
-               g_system_ptr->getTime()) &&
+               m_net_ptr->curCycle()) &&
                outNetLink->isBufferNotFull_link(vc)) {  // buffer backpressure
 
                 // Just removing the flit
                 flit *t_flit = m_ni_buffers[vc]->getTopFlit();
-                t_flit->set_time(g_system_ptr->getTime() + 1);
+                t_flit->set_time(m_net_ptr->curCycle() + 1);
                 outSrcQueue->insert(t_flit);
 
                 // schedule the out link
@@ -332,7 +333,7 @@ NetworkInterface::checkReschedule()
         }
     }
     for (int vc = 0; vc < m_num_vcs; vc++) {
-        if (m_ni_buffers[vc]->isReadyForNext()) {
+        if (m_ni_buffers[vc]->isReadyForNext(m_net_ptr->curCycle())) {
             scheduleEvent(1);
             return;
         }
diff --git a/src/mem/ruby/network/garnet/flexible-pipeline/NetworkLink.cc b/src/mem/ruby/network/garnet/flexible-pipeline/NetworkLink.cc
index 2d94f6484..b9faef28d 100644
--- a/src/mem/ruby/network/garnet/flexible-pipeline/NetworkLink.cc
+++ b/src/mem/ruby/network/garnet/flexible-pipeline/NetworkLink.cc
@@ -116,7 +116,7 @@ NetworkLink::getLinkUtilization()
 bool
 NetworkLink::isReady()
 {
-    return linkBuffer->isReady();
+    return linkBuffer->isReady(curCycle());
 }
 
 void
@@ -134,11 +134,11 @@ NetworkLink::setOutPort(int port)
 void
 NetworkLink::wakeup()
 {
-    if (!link_srcQueue->isReady())
+    if (!link_srcQueue->isReady(curCycle()))
         return;
 
     flit *t_flit = link_srcQueue->getTopFlit();
-    t_flit->set_time(g_system_ptr->getTime() + m_latency);
+    t_flit->set_time(curCycle() + m_latency);
     linkBuffer->insert(t_flit);
     link_consumer->scheduleEvent(m_latency);
     m_link_utilized++;
diff --git a/src/mem/ruby/network/garnet/flexible-pipeline/Router.cc b/src/mem/ruby/network/garnet/flexible-pipeline/Router.cc
index 8e064a01f..ca82f0757 100644
--- a/src/mem/ruby/network/garnet/flexible-pipeline/Router.cc
+++ b/src/mem/ruby/network/garnet/flexible-pipeline/Router.cc
@@ -71,7 +71,7 @@ Router::addInPort(NetworkLink *in_link)
     vector<InVcState *> in_vc_vector;
     for (int i = 0; i < m_num_vcs; i++) {
         in_vc_vector.push_back(new InVcState(i));
-        in_vc_vector[i]->setState(IDLE_, g_system_ptr->getTime());
+        in_vc_vector[i]->setState(IDLE_, curCycle());
     }
     m_in_vc_state.push_back(in_vc_vector);
     m_in_link.push_back(in_link);
@@ -111,7 +111,7 @@ Router::addOutPort(NetworkLink *out_link, const NetDest& routing_table_entry,
     vector<OutVcState *> out_vc_vector;
     for (int i = 0; i < m_num_vcs; i++) {
         out_vc_vector.push_back(new OutVcState(i));
-        out_vc_vector[i]->setState(IDLE_, g_system_ptr->getTime());
+        out_vc_vector[i]->setState(IDLE_, curCycle());
     }
     m_out_vc_state.push_back(out_vc_vector);
     m_link_weights.push_back(link_weight);
@@ -137,8 +137,8 @@ Router::request_vc(int in_vc, int in_port, NetDest destination,
     int outport = getRoute(destination);
     m_in_vc_state[in_port][in_vc]->setRoute(outport);
     m_in_vc_state[in_port][in_vc]->setState(VC_AB_, request_time);
-    assert(request_time >= g_system_ptr->getTime());
-    if (request_time > g_system_ptr->getTime())
+    assert(request_time >= curCycle());
+    if (request_time > curCycle())
         m_vc_arbiter->scheduleEventAbsolute(request_time);
     else
         vc_arbitrate();
@@ -180,22 +180,21 @@ Router::vc_arbitrate()
 
             InVcState *in_vc_state = m_in_vc_state[inport][invc];
 
-            if (in_vc_state->isInState(VC_AB_, g_system_ptr->getTime())) {
+            if (in_vc_state->isInState(VC_AB_, curCycle())) {
                 int outport = in_vc_state->get_outport();
                 vector<int> valid_vcs = get_valid_vcs(invc);
                 for (int valid_vc_iter = 0; valid_vc_iter < valid_vcs.size();
                         valid_vc_iter++) {
                     if (m_out_vc_state[outport][valid_vcs[valid_vc_iter]]
-                            ->isInState(IDLE_, g_system_ptr->getTime())) {
+                            ->isInState(IDLE_, curCycle())) {
 
                         in_vc_state->grant_vc(valid_vcs[valid_vc_iter],
-                                g_system_ptr->getTime());
+                                curCycle());
 
-                        m_in_link[inport]->grant_vc_link(invc,
-                                g_system_ptr->getTime());
+                        m_in_link[inport]->grant_vc_link(invc, curCycle());
 
                         m_out_vc_state[outport][valid_vcs[valid_vc_iter]]
-                            ->setState(VC_AB_, g_system_ptr->getTime());
+                            ->setState(VC_AB_, curCycle());
                         break;
                     }
                 }
@@ -270,8 +269,7 @@ Router::routeCompute(flit *m_flit, int inport)
     assert(m_net_ptr->getNumPipeStages() >= 1);
 
     // Subtract 1 as 1 cycle will be consumed in scheduling the output link
-    m_flit->set_time(g_system_ptr->getTime() +
-                     (m_net_ptr->getNumPipeStages() - 1));
+    m_flit->set_time(curCycle() + (m_net_ptr->getNumPipeStages() - 1));
     m_flit->set_vc(outvc);
     m_router_buffers[outport][outvc]->insert(m_flit);
 
@@ -283,25 +281,18 @@ Router::routeCompute(flit *m_flit, int inport)
         NetDest destination = nm->getInternalDestination();
 
         if (m_net_ptr->getNumPipeStages() > 1) {
-            m_out_vc_state[outport][outvc]->setState(VC_AB_,
-                g_system_ptr->getTime() + 1);
-
+            m_out_vc_state[outport][outvc]->setState(VC_AB_, curCycle() + 1);
             m_out_link[outport]->request_vc_link(outvc, destination,
-                g_system_ptr->getTime() + 1);
+                curCycle() + 1);
         } else {
-            m_out_vc_state[outport][outvc]->setState(VC_AB_,
-                g_system_ptr->getTime());
-
+            m_out_vc_state[outport][outvc]->setState(VC_AB_, curCycle());
             m_out_link[outport]->request_vc_link(outvc, destination,
-                g_system_ptr->getTime());
+                curCycle());
         }
     }
     if ((m_flit->get_type() == TAIL_) || (m_flit->get_type() == HEAD_TAIL_)) {
-        m_in_vc_state[inport][invc]->setState(IDLE_,
-            g_system_ptr->getTime() + 1);
-
-        m_in_link[inport]->release_vc_link(invc,
-            g_system_ptr->getTime() + 1);
+        m_in_vc_state[inport][invc]->setState(IDLE_, curCycle() + 1);
+        m_in_link[inport]->release_vc_link(invc, curCycle() + 1);
     }
 }
 
@@ -325,8 +316,7 @@ Router::wakeup()
 
         // checking the incoming link
         if (m_in_link[incoming_port]->isReady()) {
-            DPRINTF(RubyNetwork, "m_id: %d, Time: %lld\n",
-                    m_id, g_system_ptr->getTime());
+            DPRINTF(RubyNetwork, "m_id: %d, Time: %lld\n", m_id, curCycle());
             t_flit = m_in_link[incoming_port]->peekLink();
             routeCompute(t_flit, incoming_port);
             m_in_link[incoming_port]->consumeLink();
@@ -360,16 +350,16 @@ Router::scheduleOutputLinks()
             if (vc_tolookat == m_num_vcs)
                 vc_tolookat = 0;
 
-            if (m_router_buffers[port][vc_tolookat]->isReady()) {
+            if (m_router_buffers[port][vc_tolookat]->isReady(curCycle())) {
 
                 // models buffer backpressure
                 if (m_out_vc_state[port][vc_tolookat]->isInState(ACTIVE_,
-                   g_system_ptr->getTime()) &&
+                   curCycle()) &&
                    m_out_link[port]->isBufferNotFull_link(vc_tolookat)) {
 
                     flit *t_flit =
                         m_router_buffers[port][vc_tolookat]->getTopFlit();
-                    t_flit->set_time(g_system_ptr->getTime() + 1 );
+                    t_flit->set_time(curCycle() + 1 );
                     m_out_src_queue[port]->insert(t_flit);
                     m_out_link[port]->scheduleEvent(1);
                     break; // done for this port
@@ -392,7 +382,7 @@ Router::checkReschedule()
 {
     for (int port = 0; port < m_out_link.size(); port++) {
         for (int vc = 0; vc < m_num_vcs; vc++) {
-            if (m_router_buffers[port][vc]->isReadyForNext()) {
+            if (m_router_buffers[port][vc]->isReadyForNext(curCycle())) {
                 scheduleEvent(1);
                 return;
             }
@@ -405,9 +395,7 @@ Router::check_arbiter_reschedule()
 {
     for (int port = 0; port < m_in_link.size(); port++) {
         for (int vc = 0; vc < m_num_vcs; vc++) {
-            if (m_in_vc_state[port][vc]->isInState(VC_AB_,
-               g_system_ptr->getTime() + 1)) {
-
+            if (m_in_vc_state[port][vc]->isInState(VC_AB_, curCycle() + 1)) {
                 m_vc_arbiter->scheduleEvent(1);
                 return;
             }
diff --git a/src/mem/ruby/network/garnet/flexible-pipeline/flit.cc b/src/mem/ruby/network/garnet/flexible-pipeline/flit.cc
index 161625978..6e858199b 100644
--- a/src/mem/ruby/network/garnet/flexible-pipeline/flit.cc
+++ b/src/mem/ruby/network/garnet/flexible-pipeline/flit.cc
@@ -30,12 +30,12 @@
 
 #include "mem/ruby/network/garnet/flexible-pipeline/flit.hh"
 
-flit::flit(int id, int  vc, int vnet, int size, MsgPtr msg_ptr)
+flit::flit(int id, int  vc, int vnet, int size, MsgPtr msg_ptr, Time curTime)
 {
     m_size = size;
     m_msg_ptr = msg_ptr;
-    m_enqueue_time = g_system_ptr->getTime();
-    m_time = g_system_ptr->getTime();
+    m_enqueue_time = curTime;
+    m_time = curTime;
     m_id = id;
     m_vnet = vnet;
     m_vc = vc;
diff --git a/src/mem/ruby/network/garnet/flexible-pipeline/flit.hh b/src/mem/ruby/network/garnet/flexible-pipeline/flit.hh
index 66cd604ab..9e1168409 100644
--- a/src/mem/ruby/network/garnet/flexible-pipeline/flit.hh
+++ b/src/mem/ruby/network/garnet/flexible-pipeline/flit.hh
@@ -40,7 +40,7 @@
 class flit
 {
   public:
-    flit(int id, int vc, int vnet, int size, MsgPtr msg_ptr);
+    flit(int id, int vc, int vnet, int size, MsgPtr msg_ptr, Time curTime);
 
     int get_size();
     int get_id();
diff --git a/src/mem/ruby/network/garnet/flexible-pipeline/flitBuffer.cc b/src/mem/ruby/network/garnet/flexible-pipeline/flitBuffer.cc
index 9446c812a..fd9922af7 100644
--- a/src/mem/ruby/network/garnet/flexible-pipeline/flitBuffer.cc
+++ b/src/mem/ruby/network/garnet/flexible-pipeline/flitBuffer.cc
@@ -51,22 +51,22 @@ flitBuffer::isEmpty()
 }
 
 bool
-flitBuffer::isReady()
+flitBuffer::isReady(Time curTime)
 {
     if (m_buffer.size() != 0 ) {
         flit *t_flit = m_buffer.front();
-        if (t_flit->get_time() <= g_system_ptr->getTime())
+        if (t_flit->get_time() <= curTime)
             return true;
     }
     return false;
 }
 
 bool
-flitBuffer::isReadyForNext()
+flitBuffer::isReadyForNext(Time curTime)
 {
     if (m_buffer.size() != 0 ) {
         flit *t_flit = m_buffer.front();
-        if (t_flit->get_time() <= (g_system_ptr->getTime() + 1))
+        if (t_flit->get_time() <= (curTime + 1))
             return true;
     }
     return false;
diff --git a/src/mem/ruby/network/garnet/flexible-pipeline/flitBuffer.hh b/src/mem/ruby/network/garnet/flexible-pipeline/flitBuffer.hh
index 3170c6c78..263dcb902 100644
--- a/src/mem/ruby/network/garnet/flexible-pipeline/flitBuffer.hh
+++ b/src/mem/ruby/network/garnet/flexible-pipeline/flitBuffer.hh
@@ -43,8 +43,8 @@ class flitBuffer
     flitBuffer();
     flitBuffer(int maximum_size);
 
-    bool isReady();
-    bool isReadyForNext();
+    bool isReady(Time curTime);
+    bool isReadyForNext(Time curTime);
     bool isFull();
     bool isEmpty();
     void setMaxSize(int maximum);