src/mem/ruby/system/TimerTable.cc

   1 /*
   2  * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions are
   7  * met: redistributions of source code must retain the above copyright
   8  * notice, this list of conditions and the following disclaimer;
   9  * redistributions in binary form must reproduce the above copyright
  10  * notice, this list of conditions and the following disclaimer in the
  11  * documentation and/or other materials provided with the distribution;
  12  * neither the name of the copyright holders nor the names of its
  13  * contributors may be used to endorse or promote products derived from
  14  * this software without specific prior written permission.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  17  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  18  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  19  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  20  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  21  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  22  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  26  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  */
  28
  29 #include "mem/ruby/common/Global.hh"
  30 #include "mem/ruby/system/System.hh"
  31 #include "mem/ruby/system/TimerTable.hh"
  32
  33 TimerTable::TimerTable()
  34 {
  35     m_consumer_ptr  = NULL;
  36     m_clockobj_ptr = NULL;
  37
  38     m_next_valid = false;
  39     m_next_address = Address(0);
  40     m_next_time = 0;
  41 }
  42
  43 bool
  44 TimerTable::isReady() const
  45 {
  46     if (m_map.empty())
  47         return false;
  48
  49     if (!m_next_valid) {
  50         updateNext();
  51     }
  52     assert(m_next_valid);
  53     return (m_clockobj_ptr->curCycle() >= m_next_time);
  54 }
  55
  56 const Address&
  57 TimerTable::readyAddress() const
  58 {
  59     assert(isReady());
  60
  61     if (!m_next_valid) {
  62         updateNext();
  63     }
  64     assert(m_next_valid);
  65     return m_next_address;
  66 }
  67
  68 void
  69 TimerTable::set(const Address& address, Cycles relative_latency)
  70 {
  71     assert(address == line_address(address));
  72     assert(relative_latency > 0);
  73     assert(!m_map.count(address));
  74
  75     Cycles ready_time = m_clockobj_ptr->curCycle() + relative_latency;
  76     m_map[address] = ready_time;
  77     assert(m_consumer_ptr != NULL);
  78     m_consumer_ptr->scheduleEventAbsolute(ready_time);
  79     m_next_valid = false;
  80
  81     // Don't always recalculate the next ready address
  82     if (ready_time <= m_next_time) {
  83         m_next_valid = false;
  84     }
  85 }
  86
  87 void
  88 TimerTable::unset(const Address& address)
  89 {
  90     assert(address == line_address(address));
  91     assert(m_map.count(address));
  92     m_map.erase(address);
  93
  94     // Don't always recalculate the next ready address
  95     if (address == m_next_address) {
  96         m_next_valid = false;
  97     }
  98 }
  99
 100 void
 101 TimerTable::print(std::ostream& out) const
 102 {
 103 }
 104
 105 void
 106 TimerTable::updateNext() const
 107 {
 108     if (m_map.empty()) {
 109         assert(!m_next_valid);
 110         return;
 111     }
 112
 113     AddressMap::const_iterator i = m_map.begin();
 114     AddressMap::const_iterator end = m_map.end();
 115
 116     m_next_address = i->first;
 117     m_next_time = i->second;
 118     ++i;
 119
 120     for (; i != end; ++i) {
 121         if (i->second < m_next_time) {
 122             m_next_address = i->first;
 123             m_next_time = i->second;
 124         }
 125     }
 126
 127     m_next_valid = true;
 128 }