timing.hh revision 5496:6899b894166f
1/* 2 * Copyright (c) 2002-2005 The Regents of The University of Michigan 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 * Authors: Steve Reinhardt 29 */ 30 31#ifndef __CPU_SIMPLE_TIMING_HH__ 32#define __CPU_SIMPLE_TIMING_HH__ 33 34#include "cpu/simple/base.hh" 35 36class TimingSimpleCPU : public BaseSimpleCPU 37{ 38 public: 39 40 struct Params : public BaseSimpleCPU::Params { 41 }; 42 43 TimingSimpleCPU(Params *params); 44 virtual ~TimingSimpleCPU(); 45 46 virtual void init(); 47 48 public: 49 Event *drainEvent; 50 51 private: 52 53 class CpuPort : public Port 54 { 55 protected: 56 TimingSimpleCPU *cpu; 57 Tick lat; 58 59 public: 60 61 CpuPort(const std::string &_name, TimingSimpleCPU *_cpu, Tick _lat) 62 : Port(_name, _cpu), cpu(_cpu), lat(_lat) 63 { } 64 65 bool snoopRangeSent; 66 67 protected: 68 69 virtual Tick recvAtomic(PacketPtr pkt); 70 71 virtual void recvFunctional(PacketPtr pkt); 72 73 virtual void recvStatusChange(Status status); 74 75 virtual void getDeviceAddressRanges(AddrRangeList &resp, 76 bool &snoop) 77 { resp.clear(); snoop = false; } 78 79 struct TickEvent : public Event 80 { 81 PacketPtr pkt; 82 TimingSimpleCPU *cpu; 83 84 TickEvent(TimingSimpleCPU *_cpu) 85 :Event(&mainEventQueue), cpu(_cpu) {} 86 const char *description() const { return "Timing CPU tick"; } 87 void schedule(PacketPtr _pkt, Tick t); 88 }; 89 90 }; 91 92 class IcachePort : public CpuPort 93 { 94 public: 95 96 IcachePort(TimingSimpleCPU *_cpu, Tick _lat) 97 : CpuPort(_cpu->name() + "-iport", _cpu, _lat), tickEvent(_cpu) 98 { } 99 100 protected: 101 102 virtual bool recvTiming(PacketPtr pkt); 103 104 virtual void recvRetry(); 105 106 struct ITickEvent : public TickEvent 107 { 108 109 ITickEvent(TimingSimpleCPU *_cpu) 110 : TickEvent(_cpu) {} 111 void process(); 112 const char *description() const { return "Timing CPU icache tick"; } 113 }; 114 115 ITickEvent tickEvent; 116 117 }; 118 119 class DcachePort : public CpuPort 120 { 121 public: 122 123 DcachePort(TimingSimpleCPU *_cpu, Tick _lat) 124 : CpuPort(_cpu->name() + "-dport", _cpu, _lat), tickEvent(_cpu) 125 { } 126 127 virtual void setPeer(Port *port); 128 129 protected: 130 131 virtual bool recvTiming(PacketPtr pkt); 132 133 virtual void recvRetry(); 134 135 struct DTickEvent : public TickEvent 136 { 137 DTickEvent(TimingSimpleCPU *_cpu) 138 : TickEvent(_cpu) {} 139 void process(); 140 const char *description() const { return "Timing CPU dcache tick"; } 141 }; 142 143 DTickEvent tickEvent; 144 145 }; 146 147 IcachePort icachePort; 148 DcachePort dcachePort; 149 150 PacketPtr ifetch_pkt; 151 PacketPtr dcache_pkt; 152 153 Tick previousTick; 154 155 public: 156 157 virtual Port *getPort(const std::string &if_name, int idx = -1); 158 159 virtual void serialize(std::ostream &os); 160 virtual void unserialize(Checkpoint *cp, const std::string §ion); 161 162 virtual unsigned int drain(Event *drain_event); 163 virtual void resume(); 164 165 void switchOut(); 166 void takeOverFrom(BaseCPU *oldCPU); 167 168 virtual void activateContext(int thread_num, int delay); 169 virtual void suspendContext(int thread_num); 170 171 template <class T> 172 Fault read(Addr addr, T &data, unsigned flags); 173 174 Fault translateDataReadAddr(Addr vaddr, Addr &paddr, 175 int size, unsigned flags); 176 177 template <class T> 178 Fault write(T data, Addr addr, unsigned flags, uint64_t *res); 179 180 Fault translateDataWriteAddr(Addr vaddr, Addr &paddr, 181 int size, unsigned flags); 182 183 void fetch(); 184 void completeIfetch(PacketPtr ); 185 void completeDataAccess(PacketPtr ); 186 void advanceInst(Fault fault); 187 188 /** 189 * Print state of address in memory system via PrintReq (for 190 * debugging). 191 */ 192 void printAddr(Addr a); 193 194 private: 195 196 typedef EventWrapper<TimingSimpleCPU, &TimingSimpleCPU::fetch> FetchEvent; 197 FetchEvent *fetchEvent; 198 199 struct IprEvent : Event { 200 Packet *pkt; 201 TimingSimpleCPU *cpu; 202 IprEvent(Packet *_pkt, TimingSimpleCPU *_cpu, Tick t); 203 virtual void process(); 204 virtual const char *description() const; 205 }; 206 207 void completeDrain(); 208}; 209 210#endif // __CPU_SIMPLE_TIMING_HH__ 211