Ruby: Remove RubyEventQueue

This patch removes RubyEventQueue. Consumer objects now rely on RubySystem
or themselves for scheduling events.

6 files changed, 50 insertions, 51 deletions

diff --git a/src/mem/ruby/network/garnet/flexible-pipeline/GarnetNetwork.cc b/src/mem/ruby/network/garnet/flexible-pipeline/GarnetNetwork.cc
index a167f5df0..e8aca533a 100644
--- a/src/mem/ruby/network/garnet/flexible-pipeline/GarnetNetwork.cc
+++ b/src/mem/ruby/network/garnet/flexible-pipeline/GarnetNetwork.cc
@@ -207,7 +207,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_eventQueue_ptr->getTime()-m_ruby_start));
+            (double(g_system_ptr->getTime()-m_ruby_start));
 
         vector<int> vc_load = m_link_ptr_vector[i]->getVcLoad();
         for (int j = 0; j < vc_load.size(); j++) {
@@ -226,7 +226,7 @@ GarnetNetwork::printLinkStats(ostream& out) const
             continue;
 
         average_vc_load[i] = (double(average_vc_load[i]) /
-            (double(g_eventQueue_ptr->getTime()) - m_ruby_start));
+            (double(g_system_ptr->getTime()) - 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 73425802b..cc7dd7146 100644
--- a/src/mem/ruby/network/garnet/flexible-pipeline/NetworkInterface.cc
+++ b/src/mem/ruby/network/garnet/flexible-pipeline/NetworkInterface.cc
@@ -67,7 +67,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_eventQueue_ptr->getTime());
+        m_out_vc_state[i]->setState(IDLE_, g_system_ptr->getTime());
     }
 }
 
@@ -166,18 +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);
-            fl->set_delay(g_eventQueue_ptr->getTime() - msg_ptr->getTime());
+            fl->set_delay(g_system_ptr->getTime() - msg_ptr->getTime());
             m_ni_buffers[vc]->insert(fl);
         }
 
-        m_out_vc_state[vc]->setState(VC_AB_, g_eventQueue_ptr->getTime());
+        m_out_vc_state[vc]->setState(VC_AB_, g_system_ptr->getTime());
 
         // 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_eventQueue_ptr->getTime());
+                                    g_system_ptr->getTime());
     }
 
     return true ;
@@ -190,7 +190,7 @@ NetworkInterface::grant_vc(int out_port, int vc, Time grant_time)
 {
     assert(m_out_vc_state[vc]->isInState(VC_AB_, grant_time));
     m_out_vc_state[vc]->grant_vc(grant_time);
-    g_eventQueue_ptr->scheduleEvent(this, 1);
+    scheduleEvent(1);
 }
 
 // The tail flit corresponding to this vc has been buffered at the next hop
@@ -200,7 +200,7 @@ NetworkInterface::release_vc(int out_port, int vc, Time release_time)
 {
     assert(m_out_vc_state[vc]->isInState(ACTIVE_, release_time));
     m_out_vc_state[vc]->setState(IDLE_, release_time);
-    g_eventQueue_ptr->scheduleEvent(this, 1);
+    scheduleEvent(1);
 }
 
 // Looking for a free output vc
@@ -220,7 +220,7 @@ NetworkInterface::calculateVC(int vnet)
             m_vc_allocator[vnet] = 0;
 
         if (m_out_vc_state[(vnet*m_vc_per_vnet) + delta]->isInState(IDLE_,
-            g_eventQueue_ptr->getTime())) {
+            g_system_ptr->getTime())) {
             return ((vnet*m_vc_per_vnet) + delta);
         }
     }
@@ -264,18 +264,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_eventQueue_ptr->getTime());
+                    m_id, g_system_ptr->getTime());
 
             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_eventQueue_ptr->getTime() + 1);
+                g_system_ptr->getTime() + 1);
         }
         int vnet = t_flit->get_vnet();
         m_net_ptr->increment_received_flits(vnet);
-        int network_delay = g_eventQueue_ptr->getTime() -
+        int network_delay = g_system_ptr->getTime() -
                             t_flit->get_enqueue_time();
         int queueing_delay = t_flit->get_delay();
         m_net_ptr->increment_network_latency(network_delay, vnet);
@@ -304,16 +304,16 @@ NetworkInterface::scheduleOutputLink()
             vc = 0;
         if (m_ni_buffers[vc]->isReady()) {
             if (m_out_vc_state[vc]->isInState(ACTIVE_,
-               g_eventQueue_ptr->getTime()) &&
+               g_system_ptr->getTime()) &&
                outNetLink->isBufferNotFull_link(vc)) {  // buffer backpressure
 
                 // Just removing the flit
                 flit *t_flit = m_ni_buffers[vc]->getTopFlit();
-                t_flit->set_time(g_eventQueue_ptr->getTime() + 1);
+                t_flit->set_time(g_system_ptr->getTime() + 1);
                 outSrcQueue->insert(t_flit);
 
                 // schedule the out link
-                g_eventQueue_ptr->scheduleEvent(outNetLink, 1);
+                outNetLink->scheduleEvent(1);
                 return;
             }
         }
@@ -325,13 +325,13 @@ NetworkInterface::checkReschedule()
 {
     for (int vnet = 0; vnet < m_virtual_networks; vnet++) {
         if (inNode_ptr[vnet]->isReady()) { // Is there a message waiting
-            g_eventQueue_ptr->scheduleEvent(this, 1);
+            scheduleEvent(1);
             return;
         }
     }
     for (int vc = 0; vc < m_num_vcs; vc++) {
         if (m_ni_buffers[vc]->isReadyForNext()) {
-            g_eventQueue_ptr->scheduleEvent(this, 1);
+            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 7da87e077..fb7c9bd44 100644
--- a/src/mem/ruby/network/garnet/flexible-pipeline/NetworkLink.cc
+++ b/src/mem/ruby/network/garnet/flexible-pipeline/NetworkLink.cc
@@ -138,9 +138,9 @@ NetworkLink::wakeup()
         return;
 
     flit *t_flit = link_srcQueue->getTopFlit();
-    t_flit->set_time(g_eventQueue_ptr->getTime() + m_latency);
+    t_flit->set_time(g_system_ptr->getTime() + m_latency);
     linkBuffer->insert(t_flit);
-    g_eventQueue_ptr->scheduleEvent(link_consumer, m_latency);
+    link_consumer->scheduleEvent(this, m_latency);
     m_link_utilized++;
     m_vc_load[t_flit->get_vc()]++;
 }
diff --git a/src/mem/ruby/network/garnet/flexible-pipeline/Router.cc b/src/mem/ruby/network/garnet/flexible-pipeline/Router.cc
index 791c0cffc..28e9fc497 100644
--- a/src/mem/ruby/network/garnet/flexible-pipeline/Router.cc
+++ b/src/mem/ruby/network/garnet/flexible-pipeline/Router.cc
@@ -72,7 +72,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_eventQueue_ptr->getTime());
+        in_vc_vector[i]->setState(IDLE_, g_system_ptr->getTime());
     }
     m_in_vc_state.push_back(in_vc_vector);
     m_in_link.push_back(in_link);
@@ -112,7 +112,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_eventQueue_ptr->getTime());
+        out_vc_vector[i]->setState(IDLE_, g_system_ptr->getTime());
     }
     m_out_vc_state.push_back(out_vc_vector);
     m_link_weights.push_back(link_weight);
@@ -138,9 +138,9 @@ 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_eventQueue_ptr->getTime());
-    if (request_time > g_eventQueue_ptr->getTime())
-        g_eventQueue_ptr->scheduleEventAbsolute(m_vc_arbiter, request_time);
+    assert(request_time >= g_system_ptr->getTime());
+    if (request_time > g_system_ptr->getTime())
+        m_vc_arbiter->scheduleEventAbsolute(request_time);
     else
         vc_arbitrate();
 }
@@ -181,22 +181,22 @@ Router::vc_arbitrate()
 
             InVcState *in_vc_state = m_in_vc_state[inport][invc];
 
-            if (in_vc_state->isInState(VC_AB_, g_eventQueue_ptr->getTime())) {
+            if (in_vc_state->isInState(VC_AB_, g_system_ptr->getTime())) {
                 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_eventQueue_ptr->getTime())) {
+                            ->isInState(IDLE_, g_system_ptr->getTime())) {
 
                         in_vc_state->grant_vc(valid_vcs[valid_vc_iter],
-                                g_eventQueue_ptr->getTime());
+                                g_system_ptr->getTime());
 
                         m_in_link[inport]->grant_vc_link(invc,
-                                g_eventQueue_ptr->getTime());
+                                g_system_ptr->getTime());
 
                         m_out_vc_state[outport][valid_vcs[valid_vc_iter]]
-                            ->setState(VC_AB_, g_eventQueue_ptr->getTime());
+                            ->setState(VC_AB_, g_system_ptr->getTime());
                         break;
                     }
                 }
@@ -233,7 +233,7 @@ Router::grant_vc(int out_port, int vc, Time grant_time)
 {
     assert(m_out_vc_state[out_port][vc]->isInState(VC_AB_, grant_time));
     m_out_vc_state[out_port][vc]->grant_vc(grant_time);
-    g_eventQueue_ptr->scheduleEvent(this, 1);
+    scheduleEvent(1);
 }
 
 void
@@ -241,7 +241,7 @@ Router::release_vc(int out_port, int vc, Time release_time)
 {
     assert(m_out_vc_state[out_port][vc]->isInState(ACTIVE_, release_time));
     m_out_vc_state[out_port][vc]->setState(IDLE_, release_time);
-    g_eventQueue_ptr->scheduleEvent(this, 1);
+    scheduleEvent(1);
 }
 
 // This function calculated the output port for a particular destination.
@@ -271,14 +271,13 @@ 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_eventQueue_ptr->getTime() +
+    m_flit->set_time(g_system_ptr->getTime() +
                      (m_net_ptr->getNumPipeStages() - 1));
     m_flit->set_vc(outvc);
     m_router_buffers[outport][outvc]->insert(m_flit);
 
     if (m_net_ptr->getNumPipeStages() > 1)
-        g_eventQueue_ptr->scheduleEvent(this,
-                                        m_net_ptr->getNumPipeStages() - 1 );
+        scheduleEvent(m_net_ptr->getNumPipeStages() - 1 );
     if ((m_flit->get_type() == HEAD_) || (m_flit->get_type() == HEAD_TAIL_)) {
         NetworkMessage *nm =
             safe_cast<NetworkMessage*>(m_flit->get_msg_ptr().get());
@@ -286,24 +285,24 @@ Router::routeCompute(flit *m_flit, int inport)
 
         if (m_net_ptr->getNumPipeStages() > 1) {
             m_out_vc_state[outport][outvc]->setState(VC_AB_,
-                g_eventQueue_ptr->getTime() + 1);
+                g_system_ptr->getTime() + 1);
 
             m_out_link[outport]->request_vc_link(outvc, destination,
-                g_eventQueue_ptr->getTime() + 1);
+                g_system_ptr->getTime() + 1);
         } else {
             m_out_vc_state[outport][outvc]->setState(VC_AB_,
-                g_eventQueue_ptr->getTime());
+                g_system_ptr->getTime());
 
             m_out_link[outport]->request_vc_link(outvc, destination,
-                g_eventQueue_ptr->getTime());
+                g_system_ptr->getTime());
         }
     }
     if ((m_flit->get_type() == TAIL_) || (m_flit->get_type() == HEAD_TAIL_)) {
         m_in_vc_state[inport][invc]->setState(IDLE_,
-            g_eventQueue_ptr->getTime() + 1);
+            g_system_ptr->getTime() + 1);
 
         m_in_link[inport]->release_vc_link(invc,
-            g_eventQueue_ptr->getTime() + 1);
+            g_system_ptr->getTime() + 1);
     }
 }
 
@@ -328,7 +327,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_eventQueue_ptr->getTime());
+                    m_id, g_system_ptr->getTime());
             t_flit = m_in_link[incoming_port]->peekLink();
             routeCompute(t_flit, incoming_port);
             m_in_link[incoming_port]->consumeLink();
@@ -366,14 +365,14 @@ Router::scheduleOutputLinks()
 
                 // models buffer backpressure
                 if (m_out_vc_state[port][vc_tolookat]->isInState(ACTIVE_,
-                   g_eventQueue_ptr->getTime()) &&
+                   g_system_ptr->getTime()) &&
                    m_out_link[port]->isBufferNotFull_link(vc_tolookat)) {
 
                     flit *t_flit =
                         m_router_buffers[port][vc_tolookat]->getTopFlit();
-                    t_flit->set_time(g_eventQueue_ptr->getTime() + 1 );
+                    t_flit->set_time(g_system_ptr->getTime() + 1 );
                     m_out_src_queue[port]->insert(t_flit);
-                    g_eventQueue_ptr->scheduleEvent(m_out_link[port], 1);
+                    m_out_link[port]->scheduleEvent(1);
                     break; // done for this port
                 }
             }
@@ -395,7 +394,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()) {
-                g_eventQueue_ptr->scheduleEvent(this, 1);
+                scheduleEvent(1);
                 return;
             }
         }
@@ -408,9 +407,9 @@ 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_eventQueue_ptr->getTime() + 1)) {
+               g_system_ptr->getTime() + 1)) {
 
-                g_eventQueue_ptr->scheduleEvent(m_vc_arbiter, 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 2f5944c62..80b93172a 100644
--- a/src/mem/ruby/network/garnet/flexible-pipeline/flit.cc
+++ b/src/mem/ruby/network/garnet/flexible-pipeline/flit.cc
@@ -34,8 +34,8 @@ flit::flit(int id, int  vc, int vnet, int size, MsgPtr msg_ptr)
 {
     m_size = size;
     m_msg_ptr = msg_ptr;
-    m_enqueue_time = g_eventQueue_ptr->getTime();
-    m_time = g_eventQueue_ptr->getTime();
+    m_enqueue_time = g_system_ptr->getTime();
+    m_time = g_system_ptr->getTime();
     m_id = id;
     m_vnet = vnet;
     m_vc = vc;
diff --git a/src/mem/ruby/network/garnet/flexible-pipeline/flitBuffer.cc b/src/mem/ruby/network/garnet/flexible-pipeline/flitBuffer.cc
index 2bb297e03..7fed60762 100644
--- a/src/mem/ruby/network/garnet/flexible-pipeline/flitBuffer.cc
+++ b/src/mem/ruby/network/garnet/flexible-pipeline/flitBuffer.cc
@@ -55,7 +55,7 @@ flitBuffer::isReady()
 {
     if (m_buffer.size() != 0 ) {
         flit *t_flit = m_buffer.front();
-        if (t_flit->get_time() <= g_eventQueue_ptr->getTime())
+        if (t_flit->get_time() <= g_system_ptr->getTime())
             return true;
     }
     return false;
@@ -66,7 +66,7 @@ flitBuffer::isReadyForNext()
 {
     if (m_buffer.size() != 0 ) {
         flit *t_flit = m_buffer.front();
-        if (t_flit->get_time() <= (g_eventQueue_ptr->getTime() + 1))
+        if (t_flit->get_time() <= (g_system_ptr->getTime() + 1))
             return true;
     }
     return false;