Ruby: use ClockedObject in Consumer class

Many Ruby structures inherit from the Consumer, which is used for scheduling
events. The Consumer used to relay on an Event Manager for scheduling events
and on g_system_ptr for time. With this patch, the Consumer will now use a
ClockedObject to schedule events and to query for current time. This resulted
in several structures being converted from SimObjects to ClockedObjects. Also,
the MessageBuffer class now requires a pointer to a ClockedObject so as to
query for time.

1 files changed, 35 insertions, 50 deletions

diff --git a/src/mem/ruby/buffers/MessageBuffer.cc b/src/mem/ruby/buffers/MessageBuffer.cc
index f960cc033..446586f5a 100644
--- a/src/mem/ruby/buffers/MessageBuffer.cc
+++ b/src/mem/ruby/buffers/MessageBuffer.cc
@@ -42,6 +42,8 @@ MessageBuffer::MessageBuffer(const string &name)
 {
     m_msg_counter = 0;
     m_consumer_ptr = NULL;
+    m_clockobj_ptr = NULL;
+
     m_ordering_set = false;
     m_strict_fifo = true;
     m_size = 0;
@@ -66,10 +68,10 @@ MessageBuffer::MessageBuffer(const string &name)
 int
 MessageBuffer::getSize()
 {
-    if (m_time_last_time_size_checked == g_system_ptr->getTime()) {
+    if (m_time_last_time_size_checked == m_clockobj_ptr->curCycle()) {
         return m_size_last_time_size_checked;
     } else {
-        m_time_last_time_size_checked = g_system_ptr->getTime();
+        m_time_last_time_size_checked = m_clockobj_ptr->curCycle();
         m_size_last_time_size_checked = m_size;
         return m_size;
     }
@@ -89,11 +91,11 @@ MessageBuffer::areNSlotsAvailable(int n)
     // until next cycle, but enqueue operations effect the visible
     // size immediately
     int current_size = max(m_size_at_cycle_start, m_size);
-    if (m_time_last_time_pop < g_system_ptr->getTime()) {
+    if (m_time_last_time_pop < m_clockobj_ptr->curCycle()) {
         // no pops this cycle - m_size is correct
         current_size = m_size;
     } else {
-        if (m_time_last_time_enqueue < g_system_ptr->getTime()) {
+        if (m_time_last_time_enqueue < m_clockobj_ptr->curCycle()) {
             // no enqueues this cycle - m_size_at_cycle_start is correct
             current_size = m_size_at_cycle_start;
         } else {
@@ -155,9 +157,9 @@ MessageBuffer::enqueue(MsgPtr message, Time delta)
     m_size++;
 
     // record current time incase we have a pop that also adjusts my size
-    if (m_time_last_time_enqueue < g_system_ptr->getTime()) {
+    if (m_time_last_time_enqueue < m_clockobj_ptr->curCycle()) {
         m_msgs_this_cycle = 0;  // first msg this cycle
-        m_time_last_time_enqueue = g_system_ptr->getTime();
+        m_time_last_time_enqueue = m_clockobj_ptr->curCycle();
     }
     m_msgs_this_cycle++;
 
@@ -168,7 +170,7 @@ MessageBuffer::enqueue(MsgPtr message, Time delta)
     // Calculate the arrival time of the message, that is, the first
     // cycle the message can be dequeued.
     assert(delta>0);
-    Time current_time = g_system_ptr->getTime();
+    Time current_time = m_clockobj_ptr->curCycle();
     Time arrival_time = 0;
     if (!RubySystem::getRandomization() || (m_randomization == false)) {
         // No randomization
@@ -191,11 +193,10 @@ MessageBuffer::enqueue(MsgPtr message, Time delta)
         if (arrival_time < m_last_arrival_time) {
             panic("FIFO ordering violated: %s name: %s current time: %d "
                   "delta: %d arrival_time: %d last arrival_time: %d\n",
-                  *this, m_name,
-                  current_time * g_system_ptr->clockPeriod(),
-                  delta * g_system_ptr->clockPeriod(),
-                  arrival_time * g_system_ptr->clockPeriod(),
-                  m_last_arrival_time * g_system_ptr->clockPeriod());
+                  *this, m_name, current_time * m_clockobj_ptr->clockPeriod(),
+                  delta * m_clockobj_ptr->clockPeriod(),
+                  arrival_time * m_clockobj_ptr->clockPeriod(),
+                  m_last_arrival_time * m_clockobj_ptr->clockPeriod());
         }
     }
 
@@ -208,10 +209,10 @@ MessageBuffer::enqueue(MsgPtr message, Time delta)
     Message* msg_ptr = message.get();
     assert(msg_ptr != NULL);
 
-    assert(g_system_ptr->getTime() >= msg_ptr->getLastEnqueueTime() &&
+    assert(m_clockobj_ptr->curCycle() >= msg_ptr->getLastEnqueueTime() &&
            "ensure we aren't dequeued early");
 
-    msg_ptr->setDelayedCycles(g_system_ptr->getTime() -
+    msg_ptr->setDelayedCycles(m_clockobj_ptr->curCycle() -
                               msg_ptr->getLastEnqueueTime() +
                               msg_ptr->getDelayedCycles());
     msg_ptr->setLastEnqueueTime(arrival_time);
@@ -222,9 +223,8 @@ MessageBuffer::enqueue(MsgPtr message, Time delta)
     push_heap(m_prio_heap.begin(), m_prio_heap.end(),
         greater<MessageBufferNode>());
 
-    DPRINTF(RubyQueue, "Enqueue with arrival_time %lld.\n",
-            arrival_time * g_system_ptr->clockPeriod());
-    DPRINTF(RubyQueue, "Enqueue Message: %s.\n", (*(message.get())));
+    DPRINTF(RubyQueue, "Enqueue arrival_time: %lld, Message: %s\n",
+            arrival_time * m_clockobj_ptr->clockPeriod(), *(message.get()));
 
     // Schedule the wakeup
     if (m_consumer_ptr != NULL) {
@@ -235,18 +235,11 @@ MessageBuffer::enqueue(MsgPtr message, Time delta)
     }
 }
 
-int
+Time
 MessageBuffer::dequeue_getDelayCycles(MsgPtr& message)
 {
-    int delay_cycles = -1;  // null value
-
     dequeue(message);
-
-    // get the delay cycles
-    delay_cycles = setAndReturnDelayCycles(message);
-
-    assert(delay_cycles >= 0);
-    return delay_cycles;
+    return setAndReturnDelayCycles(message);
 }
 
 void
@@ -259,21 +252,17 @@ MessageBuffer::dequeue(MsgPtr& message)
     DPRINTF(RubyQueue, "Enqueue message is %s\n", (*(message.get())));
 }
 
-int
+Time
 MessageBuffer::dequeue_getDelayCycles()
 {
-    int delay_cycles = -1;  // null value
-
     // get MsgPtr of the message about to be dequeued
     MsgPtr message = m_prio_heap.front().m_msgptr;
 
     // get the delay cycles
-    delay_cycles = setAndReturnDelayCycles(message);
-
+    Time delayCycles = setAndReturnDelayCycles(message);
     dequeue();
 
-    assert(delay_cycles >= 0);
-    return delay_cycles;
+    return delayCycles;
 }
 
 void
@@ -287,9 +276,9 @@ MessageBuffer::pop()
 
     // record previous size and time so the current buffer size isn't
     // adjusted until next cycle
-    if (m_time_last_time_pop < g_system_ptr->getTime()) {
+    if (m_time_last_time_pop < m_clockobj_ptr->curCycle()) {
         m_size_at_cycle_start = m_size;
-        m_time_last_time_pop = g_system_ptr->getTime();
+        m_time_last_time_pop = m_clockobj_ptr->curCycle();
     }
     m_size--;
 }
@@ -315,11 +304,11 @@ MessageBuffer::recycle()
     MessageBufferNode node = m_prio_heap.front();
     pop_heap(m_prio_heap.begin(), m_prio_heap.end(),
         greater<MessageBufferNode>());
-    node.m_time = g_system_ptr->getTime() + m_recycle_latency;
+    node.m_time = m_clockobj_ptr->curCycle() + m_recycle_latency;
     m_prio_heap.back() = node;
     push_heap(m_prio_heap.begin(), m_prio_heap.end(),
         greater<MessageBufferNode>());
-    m_consumer_ptr->scheduleEventAbsolute(g_system_ptr->getTime() +
+    m_consumer_ptr->scheduleEventAbsolute(m_clockobj_ptr->curCycle() +
                                           m_recycle_latency);
 }
 
@@ -335,7 +324,7 @@ MessageBuffer::reanalyzeMessages(const Address& addr)
     //
     while(!m_stall_msg_map[addr].empty()) {
         m_msg_counter++;
-        MessageBufferNode msgNode(g_system_ptr->getTime() + 1,
+        MessageBufferNode msgNode(m_clockobj_ptr->curCycle() + 1,
                                   m_msg_counter, 
                                   m_stall_msg_map[addr].front());
 
@@ -364,7 +353,7 @@ MessageBuffer::reanalyzeAllMessages()
 
         while(!(map_iter->second).empty()) {
             m_msg_counter++;
-            MessageBufferNode msgNode(g_system_ptr->getTime() + 1,
+            MessageBufferNode msgNode(m_clockobj_ptr->curCycle() + 1,
                                       m_msg_counter, 
                                       (map_iter->second).front());
 
@@ -397,23 +386,19 @@ MessageBuffer::stallMessage(const Address& addr)
     (m_stall_msg_map[addr]).push_back(message);
 }
 
-int
+Time
 MessageBuffer::setAndReturnDelayCycles(MsgPtr msg_ptr)
 {
-    int delay_cycles = -1;  // null value
-
     // get the delay cycles of the message at the top of the queue
 
     // this function should only be called on dequeue
     // ensure the msg hasn't been enqueued
-    assert(msg_ptr->getLastEnqueueTime() <= g_system_ptr->getTime());
-    msg_ptr->setDelayedCycles(g_system_ptr->getTime() -
-                              msg_ptr->getLastEnqueueTime() +
-                              msg_ptr->getDelayedCycles());
-    delay_cycles = msg_ptr->getDelayedCycles();
+    assert(msg_ptr->getLastEnqueueTime() <= m_clockobj_ptr->curCycle());
+    msg_ptr->setDelayedCycles(m_clockobj_ptr->curCycle() -
+                             msg_ptr->getLastEnqueueTime() +
+                             msg_ptr->getDelayedCycles());
 
-    assert(delay_cycles >= 0);
-    return delay_cycles;
+    return msg_ptr->getDelayedCycles();
 }
 
 void
@@ -440,7 +425,7 @@ bool
 MessageBuffer::isReady() const
 {
     return ((m_prio_heap.size() > 0) &&
-            (m_prio_heap.front().m_time <= g_system_ptr->getTime()));
+            (m_prio_heap.front().m_time <= m_clockobj_ptr->curCycle()));
 }
 
 bool