/*
- * Copyright (c) 2012 ARM Limited
+ * Copyright (c) 2012-2013,2015 ARM Limited
* All rights reserved.
*
* The license below extends only to copyright in the software and shall
#define __CPU_SIMPLE_ATOMIC_HH__
#include "cpu/simple/base.hh"
+#include "cpu/simple/exec_context.hh"
+#include "mem/request.hh"
#include "params/AtomicSimpleCPU.hh"
+#include "sim/probe/probe.hh"
class AtomicSimpleCPU : public BaseSimpleCPU
{
AtomicSimpleCPU(AtomicSimpleCPUParams *params);
virtual ~AtomicSimpleCPU();
- virtual void init();
+ void init() override;
private:
- struct TickEvent : public Event
- {
- AtomicSimpleCPU *cpu;
-
- TickEvent(AtomicSimpleCPU *c);
- void process();
- const char *description() const;
- };
-
- TickEvent tickEvent;
+ EventFunctionWrapper tickEvent;
const int width;
bool locked;
const bool simulate_data_stalls;
const bool simulate_inst_stalls;
- /**
- * Drain manager to use when signaling drain completion
- *
- * This pointer is non-NULL when draining and NULL otherwise.
- */
- DrainManager *drain_manager;
-
// main simulation loop (one cycle)
void tick();
* </ul>
*/
bool isDrained() {
- return microPC() == 0 &&
+ SimpleExecContext &t_info = *threadInfo[curThread];
+
+ return t_info.thread->microPC() == 0 &&
!locked &&
- !stayAtPC;
+ !t_info.stayAtPC;
}
/**
/**
* An AtomicCPUPort overrides the default behaviour of the
- * recvAtomic and ignores the packet instead of panicking.
+ * recvAtomicSnoop and ignores the packet instead of panicking. It
+ * also provides an implementation for the purely virtual timing
+ * functions and panics on either of these.
*/
- class AtomicCPUPort : public CpuPort
+ class AtomicCPUPort : public MasterPort
{
public:
- AtomicCPUPort(const std::string &_name, BaseCPU* _cpu)
- : CpuPort(_name, _cpu)
+ AtomicCPUPort(const std::string &_name, BaseSimpleCPU* _cpu)
+ : MasterPort(_name, _cpu)
{ }
protected:
- virtual Tick recvAtomicSnoop(PacketPtr pkt)
+ bool recvTimingResp(PacketPtr pkt)
+ {
+ panic("Atomic CPU doesn't expect recvTimingResp!\n");
+ return true;
+ }
+
+ void recvReqRetry()
{
- // Snooping a coherence request, just return
- return 0;
+ panic("Atomic CPU doesn't expect recvRetry!\n");
}
};
+ class AtomicCPUDPort : public AtomicCPUPort
+ {
+
+ public:
+
+ AtomicCPUDPort(const std::string &_name, BaseSimpleCPU* _cpu)
+ : AtomicCPUPort(_name, _cpu), cpu(_cpu)
+ {
+ cacheBlockMask = ~(cpu->cacheLineSize() - 1);
+ }
+
+ bool isSnooping() const { return true; }
+
+ Addr cacheBlockMask;
+ protected:
+ BaseSimpleCPU *cpu;
+
+ virtual Tick recvAtomicSnoop(PacketPtr pkt);
+ virtual void recvFunctionalSnoop(PacketPtr pkt);
+ };
+
+
AtomicCPUPort icachePort;
- AtomicCPUPort dcachePort;
+ AtomicCPUDPort dcachePort;
bool fastmem;
Request ifetch_req;
bool dcache_access;
Tick dcache_latency;
+ /** Probe Points. */
+ ProbePointArg<std::pair<SimpleThread*, const StaticInstPtr>> *ppCommit;
+
protected:
/** Return a reference to the data port. */
- virtual CpuPort &getDataPort() { return dcachePort; }
+ MasterPort &getDataPort() override { return dcachePort; }
/** Return a reference to the instruction port. */
- virtual CpuPort &getInstPort() { return icachePort; }
+ MasterPort &getInstPort() override { return icachePort; }
+
+ /** Perform snoop for other cpu-local thread contexts. */
+ void threadSnoop(PacketPtr pkt, ThreadID sender);
public:
- unsigned int drain(DrainManager *drain_manager);
- void drainResume();
+ DrainState drain() override;
+ void drainResume() override;
+
+ void switchOut() override;
+ void takeOverFrom(BaseCPU *oldCPU) override;
- void switchOut();
- void takeOverFrom(BaseCPU *oldCPU);
+ void verifyMemoryMode() const override;
- void verifyMemoryMode() const;
+ void activateContext(ThreadID thread_num) override;
+ void suspendContext(ThreadID thread_num) override;
- virtual void activateContext(ThreadID thread_num, Cycles delay);
- virtual void suspendContext(ThreadID thread_num);
+ Fault readMem(Addr addr, uint8_t *data, unsigned size,
+ Request::Flags flags) override;
- Fault readMem(Addr addr, uint8_t *data, unsigned size, unsigned flags);
+ Fault initiateMemRead(Addr addr, unsigned size,
+ Request::Flags flags) override;
Fault writeMem(uint8_t *data, unsigned size,
- Addr addr, unsigned flags, uint64_t *res);
+ Addr addr, Request::Flags flags, uint64_t *res) override;
+
+ void regProbePoints() override;
/**
* Print state of address in memory system via PrintReq (for