src/cpu/testers/rubytest/RubyTester.cc

   1 /*
   2  * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood
   3  * Copyright (c) 2009 Advanced Micro Devices, Inc.
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions are
   8  * met: redistributions of source code must retain the above copyright
   9  * notice, this list of conditions and the following disclaimer;
  10  * redistributions in binary form must reproduce the above copyright
  11  * notice, this list of conditions and the following disclaimer in the
  12  * documentation and/or other materials provided with the distribution;
  13  * neither the name of the copyright holders nor the names of its
  14  * contributors may be used to endorse or promote products derived from
  15  * this software without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  18  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  19  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  20  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  21  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  22  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  23  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  24  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  25  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  27  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28  */
  29
  30 #include "base/misc.hh"
  31 #include "cpu/testers/rubytest/Check.hh"
  32 #include "cpu/testers/rubytest/RubyTester.hh"
  33 #include "debug/RubyTest.hh"
  34 #include "mem/ruby/common/Global.hh"
  35 #include "mem/ruby/common/SubBlock.hh"
  36 #include "mem/ruby/eventqueue/RubyEventQueue.hh"
  37 #include "mem/ruby/system/System.hh"
  38 #include "sim/sim_exit.hh"
  39
  40 RubyTester::RubyTester(const Params *p)
  41   : MemObject(p), checkStartEvent(this),
  42     m_checks_to_complete(p->checks_to_complete),
  43     m_deadlock_threshold(p->deadlock_threshold),
  44     m_wakeup_frequency(p->wakeup_frequency),
  45     m_check_flush(p->check_flush)
  46 {
  47     m_checks_completed = 0;
  48
  49     // add the check start event to the event queue
  50     schedule(checkStartEvent, 1);
  51 }
  52
  53 RubyTester::~RubyTester()
  54 {
  55     delete m_checkTable_ptr;
  56     for (int i = 0; i < ports.size(); i++)
  57         delete ports[i];
  58 }
  59
  60 void
  61 RubyTester::init()
  62 {
  63     assert(ports.size() > 0);
  64
  65     m_last_progress_vector.resize(ports.size());
  66     for (int i = 0; i < m_last_progress_vector.size(); i++) {
  67         m_last_progress_vector[i] = 0;
  68     }
  69
  70     m_num_cpu_sequencers = ports.size();
  71
  72     m_checkTable_ptr = new CheckTable(m_num_cpu_sequencers, this);
  73 }
  74
  75 Port *
  76 RubyTester::getPort(const std::string &if_name, int idx)
  77 {
  78     if (if_name != "cpuPort") {
  79         panic("RubyTester::getPort: unknown port %s requested", if_name);
  80     }
  81
  82     if (idx >= (int)ports.size()) {
  83         ports.resize(idx + 1);
  84     }
  85
  86     if (ports[idx] != NULL) {
  87         panic("RubyTester::getPort: port %d already assigned", idx);
  88     }
  89
  90     CpuPort *port = new CpuPort(csprintf("%s-port%d", name(), idx), this, idx);
  91
  92     ports[idx] = port;
  93     return port;
  94 }
  95
  96 Tick
  97 RubyTester::CpuPort::recvAtomic(PacketPtr pkt)
  98 {
  99     panic("RubyTester::CpuPort::recvAtomic() not implemented!\n");
 100     return 0;
 101 }
 102
 103 bool
 104 RubyTester::CpuPort::recvTiming(PacketPtr pkt)
 105 {
 106     // retrieve the subblock and call hitCallback
 107     RubyTester::SenderState* senderState =
 108         safe_cast<RubyTester::SenderState*>(pkt->senderState);
 109     SubBlock* subblock = senderState->subBlock;
 110     assert(subblock != NULL);
 111
 112     // pop the sender state from the packet
 113     pkt->senderState = senderState->saved;
 114
 115     tester->hitCallback(idx, subblock);
 116
 117     // Now that the tester has completed, delete the senderState
 118     // (includes sublock) and the packet, then return
 119     delete senderState;
 120     delete pkt->req;
 121     delete pkt;
 122     return true;
 123 }
 124
 125 Port*
 126 RubyTester::getCpuPort(int idx)
 127 {
 128     assert(idx >= 0 && idx < ports.size());
 129
 130     return ports[idx];
 131 }
 132
 133 void
 134 RubyTester::hitCallback(NodeID proc, SubBlock* data)
 135 {
 136     // Mark that we made progress
 137     m_last_progress_vector[proc] = g_eventQueue_ptr->getTime();
 138
 139     DPRINTF(RubyTest, "completed request for proc: %d\n", proc);
 140     DPRINTF(RubyTest, "addr: 0x%x, size: %d, data: ",
 141             data->getAddress(), data->getSize());
 142     for (int byte = 0; byte < data->getSize(); byte++) {
 143         DPRINTF(RubyTest, "%d", data->getByte(byte));
 144     }
 145     DPRINTF(RubyTest, "\n");
 146
 147     // This tells us our store has 'completed' or for a load gives us
 148     // back the data to make the check
 149     Check* check_ptr = m_checkTable_ptr->getCheck(data->getAddress());
 150     assert(check_ptr != NULL);
 151     check_ptr->performCallback(proc, data);
 152 }
 153
 154 void
 155 RubyTester::wakeup()
 156 {
 157     if (m_checks_completed < m_checks_to_complete) {
 158         // Try to perform an action or check
 159         Check* check_ptr = m_checkTable_ptr->getRandomCheck();
 160         assert(check_ptr != NULL);
 161         check_ptr->initiate();
 162
 163         checkForDeadlock();
 164
 165         schedule(checkStartEvent, curTick() + m_wakeup_frequency);
 166     } else {
 167         exitSimLoop("Ruby Tester completed");
 168     }
 169 }
 170
 171 void
 172 RubyTester::checkForDeadlock()
 173 {
 174     int size = m_last_progress_vector.size();
 175     Time current_time = g_eventQueue_ptr->getTime();
 176     for (int processor = 0; processor < size; processor++) {
 177         if ((current_time - m_last_progress_vector[processor]) >
 178                 m_deadlock_threshold) {
 179             panic("Deadlock detected: current_time: %d last_progress_time: %d "
 180                   "difference:  %d processor: %d\n",
 181                   current_time, m_last_progress_vector[processor],
 182                   current_time - m_last_progress_vector[processor], processor);
 183         }
 184     }
 185 }
 186
 187 void
 188 RubyTester::print(std::ostream& out) const
 189 {
 190     out << "[RubyTester]" << std::endl;
 191 }
 192
 193 RubyTester *
 194 RubyTesterParams::create()
 195 {
 196     return new RubyTester(this);
 197 }