2 * Copyright (c) 2002-2005 The Regents of The University of Michigan
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.
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.
28 * Authors: Steve Reinhardt
31 #include "arch/locked_mem.hh"
32 #include "arch/mmaped_ipr.hh"
33 #include "arch/utility.hh"
34 #include "base/bigint.hh"
35 #include "config/the_isa.hh"
36 #include "cpu/exetrace.hh"
37 #include "cpu/simple/timing.hh"
38 #include "mem/packet.hh"
39 #include "mem/packet_access.hh"
40 #include "params/TimingSimpleCPU.hh"
41 #include "sim/system.hh"
44 using namespace TheISA
;
47 TimingSimpleCPU::getPort(const std::string
&if_name
, int idx
)
49 if (if_name
== "dcache_port")
51 else if (if_name
== "icache_port")
54 panic("No Such Port\n");
58 TimingSimpleCPU::init()
62 for (int i
= 0; i
< threadContexts
.size(); ++i
) {
63 ThreadContext
*tc
= threadContexts
[i
];
65 // initialize CPU, including PC
66 TheISA::initCPU(tc
, _cpuId
);
72 TimingSimpleCPU::CpuPort::recvAtomic(PacketPtr pkt
)
74 panic("TimingSimpleCPU doesn't expect recvAtomic callback!");
79 TimingSimpleCPU::CpuPort::recvFunctional(PacketPtr pkt
)
81 //No internal storage to update, jusst return
86 TimingSimpleCPU::CpuPort::recvStatusChange(Status status
)
88 if (status
== RangeChange
) {
89 if (!snoopRangeSent
) {
90 snoopRangeSent
= true;
91 sendStatusChange(Port::RangeChange
);
96 panic("TimingSimpleCPU doesn't expect recvStatusChange callback!");
101 TimingSimpleCPU::CpuPort::TickEvent::schedule(PacketPtr _pkt
, Tick t
)
104 cpu
->schedule(this, t
);
107 TimingSimpleCPU::TimingSimpleCPU(TimingSimpleCPUParams
*p
)
108 : BaseSimpleCPU(p
), fetchTranslation(this), icachePort(this, p
->clock
),
109 dcachePort(this, p
->clock
), fetchEvent(this)
113 icachePort
.snoopRangeSent
= false;
114 dcachePort
.snoopRangeSent
= false;
116 ifetch_pkt
= dcache_pkt
= NULL
;
119 changeState(SimObject::Running
);
123 TimingSimpleCPU::~TimingSimpleCPU()
128 TimingSimpleCPU::serialize(ostream
&os
)
130 SimObject::State so_state
= SimObject::getState();
131 SERIALIZE_ENUM(so_state
);
132 BaseSimpleCPU::serialize(os
);
136 TimingSimpleCPU::unserialize(Checkpoint
*cp
, const string
§ion
)
138 SimObject::State so_state
;
139 UNSERIALIZE_ENUM(so_state
);
140 BaseSimpleCPU::unserialize(cp
, section
);
144 TimingSimpleCPU::drain(Event
*drain_event
)
146 // TimingSimpleCPU is ready to drain if it's not waiting for
147 // an access to complete.
148 if (_status
== Idle
|| _status
== Running
|| _status
== SwitchedOut
) {
149 changeState(SimObject::Drained
);
152 changeState(SimObject::Draining
);
153 drainEvent
= drain_event
;
159 TimingSimpleCPU::resume()
161 DPRINTF(SimpleCPU
, "Resume\n");
162 if (_status
!= SwitchedOut
&& _status
!= Idle
) {
163 assert(system
->getMemoryMode() == Enums::timing
);
165 if (fetchEvent
.scheduled())
166 deschedule(fetchEvent
);
168 schedule(fetchEvent
, nextCycle());
171 changeState(SimObject::Running
);
175 TimingSimpleCPU::switchOut()
177 assert(_status
== Running
|| _status
== Idle
);
178 _status
= SwitchedOut
;
179 numCycles
+= tickToCycles(curTick
- previousTick
);
181 // If we've been scheduled to resume but are then told to switch out,
182 // we'll need to cancel it.
183 if (fetchEvent
.scheduled())
184 deschedule(fetchEvent
);
189 TimingSimpleCPU::takeOverFrom(BaseCPU
*oldCPU
)
191 BaseCPU::takeOverFrom(oldCPU
, &icachePort
, &dcachePort
);
193 // if any of this CPU's ThreadContexts are active, mark the CPU as
194 // running and schedule its tick event.
195 for (int i
= 0; i
< threadContexts
.size(); ++i
) {
196 ThreadContext
*tc
= threadContexts
[i
];
197 if (tc
->status() == ThreadContext::Active
&& _status
!= Running
) {
203 if (_status
!= Running
) {
206 assert(threadContexts
.size() == 1);
207 previousTick
= curTick
;
212 TimingSimpleCPU::activateContext(int thread_num
, int delay
)
214 DPRINTF(SimpleCPU
, "ActivateContext %d (%d cycles)\n", thread_num
, delay
);
216 assert(thread_num
== 0);
219 assert(_status
== Idle
);
224 // kick things off by initiating the fetch of the next instruction
225 schedule(fetchEvent
, nextCycle(curTick
+ ticks(delay
)));
230 TimingSimpleCPU::suspendContext(int thread_num
)
232 DPRINTF(SimpleCPU
, "SuspendContext %d\n", thread_num
);
234 assert(thread_num
== 0);
240 assert(_status
== Running
);
242 // just change status to Idle... if status != Running,
243 // completeInst() will not initiate fetch of next instruction.
250 TimingSimpleCPU::handleReadPacket(PacketPtr pkt
)
252 RequestPtr req
= pkt
->req
;
253 if (req
->isMmapedIpr()) {
255 delay
= TheISA::handleIprRead(thread
->getTC(), pkt
);
256 new IprEvent(pkt
, this, nextCycle(curTick
+ delay
));
257 _status
= DcacheWaitResponse
;
259 } else if (!dcachePort
.sendTiming(pkt
)) {
260 _status
= DcacheRetry
;
263 _status
= DcacheWaitResponse
;
264 // memory system takes ownership of packet
267 return dcache_pkt
== NULL
;
271 TimingSimpleCPU::sendData(RequestPtr req
, uint8_t *data
, uint64_t *res
,
275 buildPacket(pkt
, req
, read
);
276 pkt
->dataDynamic
<uint8_t>(data
);
277 if (req
->getFlags().isSet(Request::NO_ACCESS
)) {
280 completeDataAccess(pkt
);
282 handleReadPacket(pkt
);
284 bool do_access
= true; // flag to suppress cache access
287 do_access
= TheISA::handleLockedWrite(thread
, req
);
288 } else if (req
->isCondSwap()) {
290 req
->setExtraData(*res
);
297 _status
= DcacheWaitResponse
;
298 completeDataAccess(pkt
);
304 TimingSimpleCPU::sendSplitData(RequestPtr req1
, RequestPtr req2
,
305 RequestPtr req
, uint8_t *data
, bool read
)
307 PacketPtr pkt1
, pkt2
;
308 buildSplitPacket(pkt1
, pkt2
, req1
, req2
, req
, data
, read
);
309 if (req
->getFlags().isSet(Request::NO_ACCESS
)) {
311 pkt1
->makeResponse();
312 completeDataAccess(pkt1
);
314 if (handleReadPacket(pkt1
)) {
315 SplitFragmentSenderState
* send_state
=
316 dynamic_cast<SplitFragmentSenderState
*>(pkt1
->senderState
);
317 send_state
->clearFromParent();
318 if (handleReadPacket(pkt2
)) {
319 send_state
= dynamic_cast<SplitFragmentSenderState
*>(
321 send_state
->clearFromParent();
326 if (handleWritePacket()) {
327 SplitFragmentSenderState
* send_state
=
328 dynamic_cast<SplitFragmentSenderState
*>(pkt1
->senderState
);
329 send_state
->clearFromParent();
331 if (handleWritePacket()) {
332 send_state
= dynamic_cast<SplitFragmentSenderState
*>(
334 send_state
->clearFromParent();
341 TimingSimpleCPU::translationFault(Fault fault
)
343 // fault may be NoFault in cases where a fault is suppressed,
344 // for instance prefetches.
345 numCycles
+= tickToCycles(curTick
- previousTick
);
346 previousTick
= curTick
;
349 // Since there was a fault, we shouldn't trace this instruction.
356 if (getState() == SimObject::Draining
) {
365 TimingSimpleCPU::buildPacket(PacketPtr
&pkt
, RequestPtr req
, bool read
)
369 cmd
= MemCmd::ReadReq
;
371 cmd
= MemCmd::LoadLockedReq
;
373 cmd
= MemCmd::WriteReq
;
375 cmd
= MemCmd::StoreCondReq
;
376 } else if (req
->isSwap()) {
377 cmd
= MemCmd::SwapReq
;
380 pkt
= new Packet(req
, cmd
, Packet::Broadcast
);
384 TimingSimpleCPU::buildSplitPacket(PacketPtr
&pkt1
, PacketPtr
&pkt2
,
385 RequestPtr req1
, RequestPtr req2
, RequestPtr req
,
386 uint8_t *data
, bool read
)
390 assert(!req1
->isMmapedIpr() && !req2
->isMmapedIpr());
392 if (req
->getFlags().isSet(Request::NO_ACCESS
)) {
393 buildPacket(pkt1
, req
, read
);
397 buildPacket(pkt1
, req1
, read
);
398 buildPacket(pkt2
, req2
, read
);
400 req
->setPhys(req1
->getPaddr(), req
->getSize(), req1
->getFlags());
401 PacketPtr pkt
= new Packet(req
, pkt1
->cmd
.responseCommand(),
404 pkt
->dataDynamic
<uint8_t>(data
);
405 pkt1
->dataStatic
<uint8_t>(data
);
406 pkt2
->dataStatic
<uint8_t>(data
+ req1
->getSize());
408 SplitMainSenderState
* main_send_state
= new SplitMainSenderState
;
409 pkt
->senderState
= main_send_state
;
410 main_send_state
->fragments
[0] = pkt1
;
411 main_send_state
->fragments
[1] = pkt2
;
412 main_send_state
->outstanding
= 2;
413 pkt1
->senderState
= new SplitFragmentSenderState(pkt
, 0);
414 pkt2
->senderState
= new SplitFragmentSenderState(pkt
, 1);
418 TimingSimpleCPU::readBytes(Addr addr
, uint8_t *data
,
419 unsigned size
, unsigned flags
)
423 const ThreadID tid
= 0;
424 const Addr pc
= thread
->readPC();
425 unsigned block_size
= dcachePort
.peerBlockSize();
426 BaseTLB::Mode mode
= BaseTLB::Read
;
429 traceData
->setAddr(addr
);
432 RequestPtr req
= new Request(asid
, addr
, size
,
433 flags
, pc
, _cpuId
, tid
);
435 Addr split_addr
= roundDown(addr
+ size
- 1, block_size
);
436 assert(split_addr
<= addr
|| split_addr
- addr
< block_size
);
438 _status
= DTBWaitResponse
;
439 if (split_addr
> addr
) {
440 RequestPtr req1
, req2
;
441 assert(!req
->isLLSC() && !req
->isSwap());
442 req
->splitOnVaddr(split_addr
, req1
, req2
);
444 WholeTranslationState
*state
=
445 new WholeTranslationState(req
, req1
, req2
, new uint8_t[size
],
447 DataTranslation
<TimingSimpleCPU
> *trans1
=
448 new DataTranslation
<TimingSimpleCPU
>(this, state
, 0);
449 DataTranslation
<TimingSimpleCPU
> *trans2
=
450 new DataTranslation
<TimingSimpleCPU
>(this, state
, 1);
452 thread
->dtb
->translateTiming(req1
, tc
, trans1
, mode
);
453 thread
->dtb
->translateTiming(req2
, tc
, trans2
, mode
);
455 WholeTranslationState
*state
=
456 new WholeTranslationState(req
, new uint8_t[size
], NULL
, mode
);
457 DataTranslation
<TimingSimpleCPU
> *translation
458 = new DataTranslation
<TimingSimpleCPU
>(this, state
);
459 thread
->dtb
->translateTiming(req
, tc
, translation
, mode
);
467 TimingSimpleCPU::read(Addr addr
, T
&data
, unsigned flags
)
469 return readBytes(addr
, (uint8_t *)&data
, sizeof(T
), flags
);
472 #ifndef DOXYGEN_SHOULD_SKIP_THIS
476 TimingSimpleCPU::read(Addr addr
, Twin64_t
&data
, unsigned flags
);
480 TimingSimpleCPU::read(Addr addr
, Twin32_t
&data
, unsigned flags
);
484 TimingSimpleCPU::read(Addr addr
, uint64_t &data
, unsigned flags
);
488 TimingSimpleCPU::read(Addr addr
, uint32_t &data
, unsigned flags
);
492 TimingSimpleCPU::read(Addr addr
, uint16_t &data
, unsigned flags
);
496 TimingSimpleCPU::read(Addr addr
, uint8_t &data
, unsigned flags
);
498 #endif //DOXYGEN_SHOULD_SKIP_THIS
502 TimingSimpleCPU::read(Addr addr
, double &data
, unsigned flags
)
504 return read(addr
, *(uint64_t*)&data
, flags
);
509 TimingSimpleCPU::read(Addr addr
, float &data
, unsigned flags
)
511 return read(addr
, *(uint32_t*)&data
, flags
);
516 TimingSimpleCPU::read(Addr addr
, int32_t &data
, unsigned flags
)
518 return read(addr
, (uint32_t&)data
, flags
);
522 TimingSimpleCPU::handleWritePacket()
524 RequestPtr req
= dcache_pkt
->req
;
525 if (req
->isMmapedIpr()) {
527 delay
= TheISA::handleIprWrite(thread
->getTC(), dcache_pkt
);
528 new IprEvent(dcache_pkt
, this, nextCycle(curTick
+ delay
));
529 _status
= DcacheWaitResponse
;
531 } else if (!dcachePort
.sendTiming(dcache_pkt
)) {
532 _status
= DcacheRetry
;
534 _status
= DcacheWaitResponse
;
535 // memory system takes ownership of packet
538 return dcache_pkt
== NULL
;
542 TimingSimpleCPU::writeTheseBytes(uint8_t *data
, unsigned size
,
543 Addr addr
, unsigned flags
, uint64_t *res
)
546 const ThreadID tid
= 0;
547 const Addr pc
= thread
->readPC();
548 unsigned block_size
= dcachePort
.peerBlockSize();
549 BaseTLB::Mode mode
= BaseTLB::Write
;
552 traceData
->setAddr(addr
);
555 RequestPtr req
= new Request(asid
, addr
, size
,
556 flags
, pc
, _cpuId
, tid
);
558 Addr split_addr
= roundDown(addr
+ size
- 1, block_size
);
559 assert(split_addr
<= addr
|| split_addr
- addr
< block_size
);
561 _status
= DTBWaitResponse
;
562 if (split_addr
> addr
) {
563 RequestPtr req1
, req2
;
564 assert(!req
->isLLSC() && !req
->isSwap());
565 req
->splitOnVaddr(split_addr
, req1
, req2
);
567 WholeTranslationState
*state
=
568 new WholeTranslationState(req
, req1
, req2
, data
, res
, mode
);
569 DataTranslation
<TimingSimpleCPU
> *trans1
=
570 new DataTranslation
<TimingSimpleCPU
>(this, state
, 0);
571 DataTranslation
<TimingSimpleCPU
> *trans2
=
572 new DataTranslation
<TimingSimpleCPU
>(this, state
, 1);
574 thread
->dtb
->translateTiming(req1
, tc
, trans1
, mode
);
575 thread
->dtb
->translateTiming(req2
, tc
, trans2
, mode
);
577 WholeTranslationState
*state
=
578 new WholeTranslationState(req
, data
, res
, mode
);
579 DataTranslation
<TimingSimpleCPU
> *translation
=
580 new DataTranslation
<TimingSimpleCPU
>(this, state
);
581 thread
->dtb
->translateTiming(req
, tc
, translation
, mode
);
584 // Translation faults will be returned via finishTranslation()
589 TimingSimpleCPU::writeBytes(uint8_t *data
, unsigned size
,
590 Addr addr
, unsigned flags
, uint64_t *res
)
592 uint8_t *newData
= new uint8_t[size
];
593 memcpy(newData
, data
, size
);
594 return writeTheseBytes(newData
, size
, addr
, flags
, res
);
599 TimingSimpleCPU::write(T data
, Addr addr
, unsigned flags
, uint64_t *res
)
602 traceData
->setData(data
);
605 *dataP
= TheISA::htog(data
);
607 return writeTheseBytes((uint8_t *)dataP
, sizeof(T
), addr
, flags
, res
);
611 #ifndef DOXYGEN_SHOULD_SKIP_THIS
614 TimingSimpleCPU::write(Twin32_t data
, Addr addr
,
615 unsigned flags
, uint64_t *res
);
619 TimingSimpleCPU::write(Twin64_t data
, Addr addr
,
620 unsigned flags
, uint64_t *res
);
624 TimingSimpleCPU::write(uint64_t data
, Addr addr
,
625 unsigned flags
, uint64_t *res
);
629 TimingSimpleCPU::write(uint32_t data
, Addr addr
,
630 unsigned flags
, uint64_t *res
);
634 TimingSimpleCPU::write(uint16_t data
, Addr addr
,
635 unsigned flags
, uint64_t *res
);
639 TimingSimpleCPU::write(uint8_t data
, Addr addr
,
640 unsigned flags
, uint64_t *res
);
642 #endif //DOXYGEN_SHOULD_SKIP_THIS
646 TimingSimpleCPU::write(double data
, Addr addr
, unsigned flags
, uint64_t *res
)
648 return write(*(uint64_t*)&data
, addr
, flags
, res
);
653 TimingSimpleCPU::write(float data
, Addr addr
, unsigned flags
, uint64_t *res
)
655 return write(*(uint32_t*)&data
, addr
, flags
, res
);
661 TimingSimpleCPU::write(int32_t data
, Addr addr
, unsigned flags
, uint64_t *res
)
663 return write((uint32_t)data
, addr
, flags
, res
);
668 TimingSimpleCPU::finishTranslation(WholeTranslationState
*state
)
672 if (state
->getFault() != NoFault
) {
673 if (state
->isPrefetch()) {
678 translationFault(state
->getFault());
680 if (!state
->isSplit
) {
681 sendData(state
->mainReq
, state
->data
, state
->res
,
682 state
->mode
== BaseTLB::Read
);
684 sendSplitData(state
->sreqLow
, state
->sreqHigh
, state
->mainReq
,
685 state
->data
, state
->mode
== BaseTLB::Read
);
694 TimingSimpleCPU::fetch()
696 DPRINTF(SimpleCPU
, "Fetch\n");
698 if (!curStaticInst
|| !curStaticInst
->isDelayedCommit())
699 checkForInterrupts();
703 bool fromRom
= isRomMicroPC(thread
->readMicroPC());
705 if (!fromRom
&& !curMacroStaticInst
) {
706 Request
*ifetch_req
= new Request();
707 ifetch_req
->setThreadContext(_cpuId
, /* thread ID */ 0);
708 setupFetchRequest(ifetch_req
);
709 thread
->itb
->translateTiming(ifetch_req
, tc
, &fetchTranslation
,
712 _status
= IcacheWaitResponse
;
713 completeIfetch(NULL
);
715 numCycles
+= tickToCycles(curTick
- previousTick
);
716 previousTick
= curTick
;
722 TimingSimpleCPU::sendFetch(Fault fault
, RequestPtr req
, ThreadContext
*tc
)
724 if (fault
== NoFault
) {
725 ifetch_pkt
= new Packet(req
, MemCmd::ReadReq
, Packet::Broadcast
);
726 ifetch_pkt
->dataStatic(&inst
);
728 if (!icachePort
.sendTiming(ifetch_pkt
)) {
729 // Need to wait for retry
730 _status
= IcacheRetry
;
732 // Need to wait for cache to respond
733 _status
= IcacheWaitResponse
;
734 // ownership of packet transferred to memory system
739 // fetch fault: advance directly to next instruction (fault handler)
743 numCycles
+= tickToCycles(curTick
- previousTick
);
744 previousTick
= curTick
;
749 TimingSimpleCPU::advanceInst(Fault fault
)
751 if (fault
!= NoFault
|| !stayAtPC
)
754 if (_status
== Running
) {
755 // kick off fetch of next instruction... callback from icache
756 // response will cause that instruction to be executed,
757 // keeping the CPU running.
764 TimingSimpleCPU::completeIfetch(PacketPtr pkt
)
766 DPRINTF(SimpleCPU
, "Complete ICache Fetch\n");
768 // received a response from the icache: execute the received
771 assert(!pkt
|| !pkt
->isError());
772 assert(_status
== IcacheWaitResponse
);
776 numCycles
+= tickToCycles(curTick
- previousTick
);
777 previousTick
= curTick
;
779 if (getState() == SimObject::Draining
) {
791 curStaticInst
->isMemRef() && !curStaticInst
->isDataPrefetch()) {
792 // load or store: just send to dcache
793 Fault fault
= curStaticInst
->initiateAcc(this, traceData
);
794 if (_status
!= Running
) {
795 // instruction will complete in dcache response callback
796 assert(_status
== DcacheWaitResponse
||
797 _status
== DcacheRetry
|| DTBWaitResponse
);
798 assert(fault
== NoFault
);
800 if (fault
!= NoFault
&& traceData
) {
801 // If there was a fault, we shouldn't trace this instruction.
807 // @todo remove me after debugging with legion done
808 if (curStaticInst
&& (!curStaticInst
->isMicroop() ||
809 curStaticInst
->isFirstMicroop()))
813 } else if (curStaticInst
) {
814 // non-memory instruction: execute completely now
815 Fault fault
= curStaticInst
->execute(this, traceData
);
817 // keep an instruction count
818 if (fault
== NoFault
)
820 else if (traceData
) {
821 // If there was a fault, we shouldn't trace this instruction.
827 // @todo remove me after debugging with legion done
828 if (curStaticInst
&& (!curStaticInst
->isMicroop() ||
829 curStaticInst
->isFirstMicroop()))
833 advanceInst(NoFault
);
843 TimingSimpleCPU::IcachePort::ITickEvent::process()
845 cpu
->completeIfetch(pkt
);
849 TimingSimpleCPU::IcachePort::recvTiming(PacketPtr pkt
)
851 if (pkt
->isResponse() && !pkt
->wasNacked()) {
852 // delay processing of returned data until next CPU clock edge
853 Tick next_tick
= cpu
->nextCycle(curTick
);
855 if (next_tick
== curTick
)
856 cpu
->completeIfetch(pkt
);
858 tickEvent
.schedule(pkt
, next_tick
);
862 else if (pkt
->wasNacked()) {
863 assert(cpu
->_status
== IcacheWaitResponse
);
865 if (!sendTiming(pkt
)) {
866 cpu
->_status
= IcacheRetry
;
867 cpu
->ifetch_pkt
= pkt
;
870 //Snooping a Coherence Request, do nothing
875 TimingSimpleCPU::IcachePort::recvRetry()
877 // we shouldn't get a retry unless we have a packet that we're
878 // waiting to transmit
879 assert(cpu
->ifetch_pkt
!= NULL
);
880 assert(cpu
->_status
== IcacheRetry
);
881 PacketPtr tmp
= cpu
->ifetch_pkt
;
882 if (sendTiming(tmp
)) {
883 cpu
->_status
= IcacheWaitResponse
;
884 cpu
->ifetch_pkt
= NULL
;
889 TimingSimpleCPU::completeDataAccess(PacketPtr pkt
)
891 // received a response from the dcache: complete the load or store
893 assert(!pkt
->isError());
895 numCycles
+= tickToCycles(curTick
- previousTick
);
896 previousTick
= curTick
;
898 if (pkt
->senderState
) {
899 SplitFragmentSenderState
* send_state
=
900 dynamic_cast<SplitFragmentSenderState
*>(pkt
->senderState
);
904 PacketPtr big_pkt
= send_state
->bigPkt
;
907 SplitMainSenderState
* main_send_state
=
908 dynamic_cast<SplitMainSenderState
*>(big_pkt
->senderState
);
909 assert(main_send_state
);
910 // Record the fact that this packet is no longer outstanding.
911 assert(main_send_state
->outstanding
!= 0);
912 main_send_state
->outstanding
--;
914 if (main_send_state
->outstanding
) {
917 delete main_send_state
;
918 big_pkt
->senderState
= NULL
;
923 assert(_status
== DcacheWaitResponse
|| _status
== DTBWaitResponse
);
926 Fault fault
= curStaticInst
->completeAcc(pkt
, this, traceData
);
928 // keep an instruction count
929 if (fault
== NoFault
)
931 else if (traceData
) {
932 // If there was a fault, we shouldn't trace this instruction.
937 // the locked flag may be cleared on the response packet, so check
938 // pkt->req and not pkt to see if it was a load-locked
939 if (pkt
->isRead() && pkt
->req
->isLLSC()) {
940 TheISA::handleLockedRead(thread
, pkt
->req
);
948 if (getState() == SimObject::Draining
) {
960 TimingSimpleCPU::completeDrain()
962 DPRINTF(Config
, "Done draining\n");
963 changeState(SimObject::Drained
);
964 drainEvent
->process();
968 TimingSimpleCPU::DcachePort::setPeer(Port
*port
)
973 // Update the ThreadContext's memory ports (Functional/Virtual
975 cpu
->tcBase()->connectMemPorts(cpu
->tcBase());
980 TimingSimpleCPU::DcachePort::recvTiming(PacketPtr pkt
)
982 if (pkt
->isResponse() && !pkt
->wasNacked()) {
983 // delay processing of returned data until next CPU clock edge
984 Tick next_tick
= cpu
->nextCycle(curTick
);
986 if (next_tick
== curTick
) {
987 cpu
->completeDataAccess(pkt
);
989 tickEvent
.schedule(pkt
, next_tick
);
994 else if (pkt
->wasNacked()) {
995 assert(cpu
->_status
== DcacheWaitResponse
);
997 if (!sendTiming(pkt
)) {
998 cpu
->_status
= DcacheRetry
;
999 cpu
->dcache_pkt
= pkt
;
1002 //Snooping a Coherence Request, do nothing
1007 TimingSimpleCPU::DcachePort::DTickEvent::process()
1009 cpu
->completeDataAccess(pkt
);
1013 TimingSimpleCPU::DcachePort::recvRetry()
1015 // we shouldn't get a retry unless we have a packet that we're
1016 // waiting to transmit
1017 assert(cpu
->dcache_pkt
!= NULL
);
1018 assert(cpu
->_status
== DcacheRetry
);
1019 PacketPtr tmp
= cpu
->dcache_pkt
;
1020 if (tmp
->senderState
) {
1021 // This is a packet from a split access.
1022 SplitFragmentSenderState
* send_state
=
1023 dynamic_cast<SplitFragmentSenderState
*>(tmp
->senderState
);
1025 PacketPtr big_pkt
= send_state
->bigPkt
;
1027 SplitMainSenderState
* main_send_state
=
1028 dynamic_cast<SplitMainSenderState
*>(big_pkt
->senderState
);
1029 assert(main_send_state
);
1031 if (sendTiming(tmp
)) {
1032 // If we were able to send without retrying, record that fact
1033 // and try sending the other fragment.
1034 send_state
->clearFromParent();
1035 int other_index
= main_send_state
->getPendingFragment();
1036 if (other_index
> 0) {
1037 tmp
= main_send_state
->fragments
[other_index
];
1038 cpu
->dcache_pkt
= tmp
;
1039 if ((big_pkt
->isRead() && cpu
->handleReadPacket(tmp
)) ||
1040 (big_pkt
->isWrite() && cpu
->handleWritePacket())) {
1041 main_send_state
->fragments
[other_index
] = NULL
;
1044 cpu
->_status
= DcacheWaitResponse
;
1045 // memory system takes ownership of packet
1046 cpu
->dcache_pkt
= NULL
;
1049 } else if (sendTiming(tmp
)) {
1050 cpu
->_status
= DcacheWaitResponse
;
1051 // memory system takes ownership of packet
1052 cpu
->dcache_pkt
= NULL
;
1056 TimingSimpleCPU::IprEvent::IprEvent(Packet
*_pkt
, TimingSimpleCPU
*_cpu
,
1058 : pkt(_pkt
), cpu(_cpu
)
1060 cpu
->schedule(this, t
);
1064 TimingSimpleCPU::IprEvent::process()
1066 cpu
->completeDataAccess(pkt
);
1070 TimingSimpleCPU::IprEvent::description() const
1072 return "Timing Simple CPU Delay IPR event";
1077 TimingSimpleCPU::printAddr(Addr a
)
1079 dcachePort
.printAddr(a
);
1083 ////////////////////////////////////////////////////////////////////////
1085 // TimingSimpleCPU Simulation Object
1088 TimingSimpleCPUParams::create()
1092 if (workload
.size() != 1)
1093 panic("only one workload allowed");
1095 return new TimingSimpleCPU(this);