From c73c19effd8f7f9b6e2ec470f04b8f1f43ce7354 Mon Sep 17 00:00:00 2001 From: Gabe Black Date: Sun, 13 Oct 2019 22:02:35 -0700 Subject: [PATCH] cpu: Make accesses to comInstEventQueue indirect through methods. This lets us move the event queue itself around, or change how those services are provided. Change-Id: Ie36665b353cf9788968f253cf281a854a6eff4f4 Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/22107 Reviewed-by: Andreas Sandberg Maintainer: Gabe Black Tested-by: kokoro --- src/base/remote_gdb.cc | 13 ++++--------- src/cpu/base.cc | 10 +++++----- src/cpu/base.hh | 25 +++++++++++++++++++++++++ src/cpu/kvm/base.cc | 11 ++++------- src/cpu/minor/execute.cc | 2 +- src/cpu/o3/cpu.cc | 2 +- src/cpu/o3/probe/elastic_trace.cc | 4 ++-- src/cpu/simple/base.cc | 2 +- 8 files changed, 43 insertions(+), 26 deletions(-) diff --git a/src/base/remote_gdb.cc b/src/base/remote_gdb.cc index 3dde235f0..b45ef1037 100644 --- a/src/base/remote_gdb.cc +++ b/src/base/remote_gdb.cc @@ -317,12 +317,6 @@ break_type(char c) std::map hardBreakMap; -EventQueue * -getComInstEventQueue(ThreadContext *tc) -{ - return tc->getCpuPtr()->comInstEventQueue[tc->threadId()]; -} - } BaseRemoteGDB::BaseRemoteGDB(System *_system, ThreadContext *c, int _port) : @@ -759,17 +753,18 @@ BaseRemoteGDB::setTempBreakpoint(Addr bkpt) void BaseRemoteGDB::scheduleInstCommitEvent(Event *ev, int delta) { - EventQueue *eq = getComInstEventQueue(tc); + auto *cpu = tc->getCpuPtr(); // Here "ticks" aren't simulator ticks which measure time, they're // instructions committed by the CPU. - eq->schedule(ev, eq->getCurTick() + delta); + cpu->scheduleInstCountEvent(tc->threadId(), ev, + cpu->getCurrentInstCount(tc->threadId()) + delta); } void BaseRemoteGDB::descheduleInstCommitEvent(Event *ev) { if (ev->scheduled()) - getComInstEventQueue(tc)->deschedule(ev); + tc->getCpuPtr()->descheduleInstCountEvent(tc->threadId(), ev); } std::map BaseRemoteGDB::command_map = { diff --git a/src/cpu/base.cc b/src/cpu/base.cc index 7e0e79e96..a4ffb1031 100644 --- a/src/cpu/base.cc +++ b/src/cpu/base.cc @@ -191,7 +191,7 @@ BaseCPU::BaseCPU(Params *p, bool is_checker) *counter = numThreads; for (ThreadID tid = 0; tid < numThreads; ++tid) { Event *event = new CountedExitEvent(cause, *counter); - comInstEventQueue[tid]->schedule(event, p->max_insts_all_threads); + scheduleInstCountEvent(tid, event, p->max_insts_all_threads); } } @@ -726,16 +726,16 @@ BaseCPU::unserialize(CheckpointIn &cp) void BaseCPU::scheduleInstStop(ThreadID tid, Counter insts, const char *cause) { - const Tick now(comInstEventQueue[tid]->getCurTick()); + const Tick now(getCurrentInstCount(tid)); Event *event(new LocalSimLoopExitEvent(cause, 0)); - comInstEventQueue[tid]->schedule(event, now + insts); + scheduleInstCountEvent(tid, event, now + insts); } -uint64_t +Tick BaseCPU::getCurrentInstCount(ThreadID tid) { - return Tick(comInstEventQueue[tid]->getCurTick()); + return comInstEventQueue[tid]->getCurTick(); } AddressMonitor::AddressMonitor() { diff --git a/src/cpu/base.hh b/src/cpu/base.hh index cb23cb1ba..0424945cb 100644 --- a/src/cpu/base.hh +++ b/src/cpu/base.hh @@ -465,6 +465,31 @@ class BaseCPU : public ClockedObject */ uint64_t getCurrentInstCount(ThreadID tid); + Tick + nextInstEventCount(ThreadID tid) + { + return comInstEventQueue[tid]->empty() ? + MaxTick : comInstEventQueue[tid]->nextTick(); + } + + void + serviceInstCountEvents(ThreadID tid, Tick count) + { + comInstEventQueue[tid]->serviceEvents(count); + } + + void + scheduleInstCountEvent(ThreadID tid, Event *event, Tick count) + { + comInstEventQueue[tid]->schedule(event, count); + } + + void + descheduleInstCountEvent(ThreadID tid, Event *event) + { + comInstEventQueue[tid]->deschedule(event); + } + public: /** * @{ diff --git a/src/cpu/kvm/base.cc b/src/cpu/kvm/base.cc index 0b3888976..384abb0eb 100644 --- a/src/cpu/kvm/base.cc +++ b/src/cpu/kvm/base.cc @@ -630,9 +630,7 @@ BaseKvmCPU::tick() case RunningServiceCompletion: case Running: { - const uint64_t nextInstEvent( - !comInstEventQueue[0]->empty() ? - comInstEventQueue[0]->nextTick() : UINT64_MAX); + const uint64_t nextInstEvent(nextInstEventCount(0)); // Enter into KVM and complete pending IO instructions if we // have an instruction event pending. const Tick ticksToExecute( @@ -688,7 +686,7 @@ BaseKvmCPU::tick() // Service any pending instruction events. The vCPU should // have exited in time for the event using the instruction // counter configured by setupInstStop(). - comInstEventQueue[0]->serviceEvents(ctrInsts); + serviceInstCountEvents(0, ctrInsts); if (tryDrain()) _status = Idle; @@ -1348,11 +1346,10 @@ BaseKvmCPU::ioctlRun() void BaseKvmCPU::setupInstStop() { - if (comInstEventQueue[0]->empty()) { + Tick next = nextInstEventCount(0); + if (next == MaxTick) { setupInstCounter(0); } else { - const uint64_t next(comInstEventQueue[0]->nextTick()); - assert(next > ctrInsts); setupInstCounter(next - ctrInsts); } diff --git a/src/cpu/minor/execute.cc b/src/cpu/minor/execute.cc index 24506fceb..9317f61f4 100644 --- a/src/cpu/minor/execute.cc +++ b/src/cpu/minor/execute.cc @@ -870,7 +870,7 @@ Execute::doInstCommitAccounting(MinorDynInstPtr inst) cpu.system->totalNumInsts++; /* Act on events related to instruction counts */ - cpu.comInstEventQueue[inst->id.threadId]->serviceEvents(thread->numInst); + cpu.serviceInstCountEvents(inst->id.threadId, thread->numInst); } thread->numOp++; thread->numOps++; diff --git a/src/cpu/o3/cpu.cc b/src/cpu/o3/cpu.cc index 5871e6584..e49d4997e 100644 --- a/src/cpu/o3/cpu.cc +++ b/src/cpu/o3/cpu.cc @@ -1521,7 +1521,7 @@ FullO3CPU::instDone(ThreadID tid, const DynInstPtr &inst) system->totalNumInsts++; // Check for instruction-count-based events. - comInstEventQueue[tid]->serviceEvents(thread[tid]->numInst); + serviceInstCountEvents(tid, thread[tid]->numInst); } thread[tid]->numOp++; thread[tid]->numOps++; diff --git a/src/cpu/o3/probe/elastic_trace.cc b/src/cpu/o3/probe/elastic_trace.cc index 36d8297d1..586688600 100644 --- a/src/cpu/o3/probe/elastic_trace.cc +++ b/src/cpu/o3/probe/elastic_trace.cc @@ -109,8 +109,8 @@ ElasticTrace::regProbeListeners() } else { // Schedule an event to register all elastic trace probes when // specified no. of instructions are committed. - cpu->comInstEventQueue[(ThreadID)0]->schedule(®EtraceListenersEvent, - startTraceInst); + cpu->scheduleInstCountEvent( + 0, ®EtraceListenersEvent, startTraceInst); } } diff --git a/src/cpu/simple/base.cc b/src/cpu/simple/base.cc index 248494b40..fc07fedc0 100644 --- a/src/cpu/simple/base.cc +++ b/src/cpu/simple/base.cc @@ -500,7 +500,7 @@ BaseSimpleCPU::preExecute() t_info.setMemAccPredicate(true); // check for instruction-count-based events - comInstEventQueue[curThread]->serviceEvents(t_info.numInst); + serviceInstCountEvents(curThread, t_info.numInst); // decode the instruction inst = gtoh(inst); -- 2.30.2