ruby: replace Time with Cycles (final patch in the series)

[gem5.git] / src / mem / ruby / system / TimerTable.cc

diff --git a/src/mem/ruby/system/TimerTable.cc b/src/mem/ruby/system/TimerTable.cc
index edc2de23032d1d470064eec60ce458110761e5c6..d294916113f3710e54bb2472303a3171003943de 100644 (file)
--- a/src/mem/ruby/system/TimerTable.cc
+++ b/src/mem/ruby/system/TimerTable.cc
@@ -1,4 +1,3 @@
-
 /*
  * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood
  * All rights reserved.
@@ -27,103 +26,103 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-/*
- * $Id$
- */
-
 #include "mem/ruby/common/Global.hh"
+#include "mem/ruby/system/System.hh"
 #include "mem/ruby/system/TimerTable.hh"
-#include "mem/ruby/eventqueue/RubyEventQueue.hh"
 
-TimerTable::TimerTable(Chip* chip_ptr)
+TimerTable::TimerTable()
+    : m_next_time(0)
 {
-  assert(chip_ptr != NULL);
-  m_consumer_ptr  = NULL;
-  m_chip_ptr = chip_ptr;
-  m_next_valid = false;
-  m_next_address = Address(0);
-  m_next_time = 0;
-}
+    m_consumer_ptr  = NULL;
+    m_clockobj_ptr = NULL;
 
+    m_next_valid = false;
+    m_next_address = Address(0);
+}
 
-bool TimerTable::isReady() const
+bool
+TimerTable::isReady() const
 {
-  if (m_map.size() == 0) {
-    return false;
-  }
-
-  if (!m_next_valid) {
-    updateNext();
-  }
-  assert(m_next_valid);
-  return (g_eventQueue_ptr->getTime() >= m_next_time);
+    if (m_map.empty())
+        return false;
+
+    if (!m_next_valid) {
+        updateNext();
+    }
+    assert(m_next_valid);
+    return (m_clockobj_ptr->curCycle() >= m_next_time);
 }
 
-const Address& TimerTable::readyAddress() const
+const Address&
+TimerTable::readyAddress() const
 {
-  assert(isReady());
+    assert(isReady());
 
-  if (!m_next_valid) {
-    updateNext();
-  }
-  assert(m_next_valid);
-  return m_next_address;
+    if (!m_next_valid) {
+        updateNext();
+    }
+    assert(m_next_valid);
+    return m_next_address;
 }
 
-void TimerTable::set(const Address& address, Time relative_latency)
+void
+TimerTable::set(const Address& address, Cycles relative_latency)
 {
-  assert(address == line_address(address));
-  assert(relative_latency > 0);
-  assert(m_map.exist(address) == false);
-  Time ready_time = g_eventQueue_ptr->getTime() + relative_latency;
-  m_map.add(address, ready_time);
-  assert(m_consumer_ptr != NULL);
-  g_eventQueue_ptr->scheduleEventAbsolute(m_consumer_ptr, ready_time);
-  m_next_valid = false;
-
-  // Don't always recalculate the next ready address
-  if (ready_time <= m_next_time) {
+    assert(address == line_address(address));
+    assert(relative_latency > 0);
+    assert(!m_map.count(address));
+
+    Cycles ready_time = m_clockobj_ptr->curCycle() + relative_latency;
+    m_map[address] = ready_time;
+    assert(m_consumer_ptr != NULL);
+    m_consumer_ptr->scheduleEventAbsolute(ready_time);
     m_next_valid = false;
-  }
+
+    // Don't always recalculate the next ready address
+    if (ready_time <= m_next_time) {
+        m_next_valid = false;
+    }
 }
 
-void TimerTable::unset(const Address& address)
+void
+TimerTable::unset(const Address& address)
 {
-  assert(address == line_address(address));
-  assert(m_map.exist(address) == true);
-  m_map.remove(address);
+    assert(address == line_address(address));
+    assert(m_map.count(address));
+    m_map.erase(address);
 
-  // Don't always recalculate the next ready address
-  if (address == m_next_address) {
-    m_next_valid = false;
-  }
+    // Don't always recalculate the next ready address
+    if (address == m_next_address) {
+        m_next_valid = false;
+    }
 }
 
-void TimerTable::print(ostream& out) const
+void
+TimerTable::print(std::ostream& out) const
 {
 }
 
-
-void TimerTable::updateNext() const
+void
+TimerTable::updateNext() const
 {
-  if (m_map.size() == 0) {
-    assert(m_next_valid == false);
-    return;
-  }
-
-  Vector<Address> addresses = m_map.keys();
-  m_next_address = addresses[0];
-  m_next_time = m_map.lookup(m_next_address);
-
-  // Search for the minimum time
-  int size = addresses.size();
-  for (int i=1; i<size; i++) {
-    Address maybe_next_address = addresses[i];
-    Time maybe_next_time = m_map.lookup(maybe_next_address);
-    if (maybe_next_time < m_next_time) {
-      m_next_time = maybe_next_time;
-      m_next_address= maybe_next_address;
+    if (m_map.empty()) {
+        assert(!m_next_valid);
+        return;
     }
-  }
-  m_next_valid = true;
+
+    AddressMap::const_iterator i = m_map.begin();
+    AddressMap::const_iterator end = m_map.end();
+
+    m_next_address = i->first;
+    m_next_time = i->second;
+    ++i;
+
+    for (; i != end; ++i) {
+        if (i->second < m_next_time) {
+            m_next_address = i->first;
+            m_next_time = i->second;
+        }
+    }
+
+    m_next_valid = true;
 }