src/cpu/testers/rubytest/RubyTester.hh

   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 #ifndef __CPU_RUBYTEST_RUBYTESTER_HH__
  31 #define __CPU_RUBYTEST_RUBYTESTER_HH__
  32
  33 #include <iostream>
  34 #include <string>
  35 #include <vector>
  36
  37 #include "cpu/testers/rubytest/CheckTable.hh"
  38 #include "mem/ruby/common/Global.hh"
  39 #include "mem/ruby/common/SubBlock.hh"
  40 #include "mem/ruby/system/RubyPort.hh"
  41 #include "mem/mem_object.hh"
  42 #include "mem/packet.hh"
  43 #include "params/RubyTester.hh"
  44
  45 class RubyTester : public MemObject
  46 {
  47   public:
  48     class CpuPort : public MasterPort
  49     {
  50       private:
  51         RubyTester *tester;
  52
  53       public:
  54         //
  55         // Currently, each instatiation of the RubyTester::CpuPort supports
  56         // only instruction or data requests, not both.  However, for those
  57         // RubyPorts that support both types of requests, separate InstOnly
  58         // and DataOnly CpuPorts will map to that RubyPort
  59
  60         CpuPort(const std::string &_name, RubyTester *_tester, PortID _id)
  61             : MasterPort(_name, _tester, _id), tester(_tester)
  62         {}
  63
  64       protected:
  65         virtual bool recvTimingResp(PacketPtr pkt);
  66         virtual void recvRetry()
  67         { panic("%s does not expect a retry\n", name()); }
  68     };
  69
  70     struct SenderState : public Packet::SenderState
  71     {
  72         SubBlock* subBlock;
  73         Packet::SenderState *saved;
  74
  75         SenderState(Address addr, int size,
  76                     Packet::SenderState *sender_state = NULL)
  77             : saved(sender_state)
  78         {
  79             subBlock = new SubBlock(addr, size);
  80         }
  81
  82         ~SenderState()
  83         {
  84             delete subBlock;
  85         }
  86     };
  87
  88     typedef RubyTesterParams Params;
  89     RubyTester(const Params *p);
  90     ~RubyTester();
  91
  92     virtual MasterPort &getMasterPort(const std::string &if_name,
  93                                       int idx = -1);
  94
  95     bool isInstReadableCpuPort(int idx);
  96
  97     MasterPort* getReadableCpuPort(int idx);
  98     MasterPort* getWritableCpuPort(int idx);
  99
 100     virtual void init();
 101
 102     void wakeup();
 103
 104     void incrementCheckCompletions() { m_checks_completed++; }
 105
 106     void printStats(std::ostream& out) const {}
 107     void clearStats() {}
 108     void printConfig(std::ostream& out) const {}
 109
 110     void print(std::ostream& out) const;
 111     bool getCheckFlush() { return m_check_flush; }
 112
 113     MasterID masterId() { return _masterId; }
 114   protected:
 115     class CheckStartEvent : public Event
 116     {
 117       private:
 118         RubyTester *tester;
 119
 120       public:
 121         CheckStartEvent(RubyTester *_tester)
 122             : Event(CPU_Tick_Pri), tester(_tester)
 123         {}
 124         void process() { tester->wakeup(); }
 125         virtual const char *description() const { return "RubyTester tick"; }
 126     };
 127
 128     CheckStartEvent checkStartEvent;
 129
 130     MasterID _masterId;
 131
 132   private:
 133     void hitCallback(NodeID proc, SubBlock* data);
 134
 135     void checkForDeadlock();
 136
 137     // Private copy constructor and assignment operator
 138     RubyTester(const RubyTester& obj);
 139     RubyTester& operator=(const RubyTester& obj);
 140
 141     CheckTable* m_checkTable_ptr;
 142     std::vector<Time> m_last_progress_vector;
 143
 144     int m_num_cpus;
 145     uint64 m_checks_completed;
 146     std::vector<MasterPort*> writePorts;
 147     std::vector<MasterPort*> readPorts;
 148     uint64 m_checks_to_complete;
 149     int m_deadlock_threshold;
 150     int m_num_writers;
 151     int m_num_readers;
 152     int m_wakeup_frequency;
 153     bool m_check_flush;
 154     int m_num_inst_ports;
 155 };
 156
 157 inline std::ostream&
 158 operator<<(std::ostream& out, const RubyTester& obj)
 159 {
 160     obj.print(out);
 161     out << std::flush;
 162     return out;
 163 }
 164
 165 #endif // __CPU_RUBYTEST_RUBYTESTER_HH__