branch prediction, and makes memory dependence work properly. SConscript: Added return address stack, tournament predictor. cpu/base_cpu.cc: Added debug break and print statements. cpu/base_dyn_inst.cc: cpu/base_dyn_inst.hh: Comment out possibly unneeded variables. cpu/beta_cpu/2bit_local_pred.cc: 2bit predictor no longer speculatively updates itself. cpu/beta_cpu/alpha_dyn_inst.hh: Comment formatting. cpu/beta_cpu/alpha_full_cpu.hh: Formatting cpu/beta_cpu/alpha_full_cpu_builder.cc: Added new parameters for branch predictors, and IQ parameters. cpu/beta_cpu/alpha_full_cpu_impl.hh: Register stats. cpu/beta_cpu/alpha_params.hh: Added parameters for IQ, branch predictors, and store sets. cpu/beta_cpu/bpred_unit.cc: Removed one class. cpu/beta_cpu/bpred_unit.hh: Add in RAS, stats. Changed branch predictor unit functionality so that it holds a history of past branches so it can update, and also hold a proper history of the RAS so it can be restored on branch mispredicts. cpu/beta_cpu/bpred_unit_impl.hh: Added in stats, history of branches, RAS. Now bpred unit actually modifies the instruction's predicted next PC. cpu/beta_cpu/btb.cc: Add in sanity checks. cpu/beta_cpu/comm.hh: Add in communication where needed, remove it where it's not. cpu/beta_cpu/commit.hh: cpu/beta_cpu/rename.hh: cpu/beta_cpu/rename_impl.hh: Add in stats. cpu/beta_cpu/commit_impl.hh: Stats, update what is sent back on branch mispredict. cpu/beta_cpu/cpu_policy.hh: Change the bpred unit being used. cpu/beta_cpu/decode.hh: cpu/beta_cpu/decode_impl.hh: Stats. cpu/beta_cpu/fetch.hh: Stats, change squash so it can handle squashes from decode differently than squashes from commit. cpu/beta_cpu/fetch_impl.hh: Add in stats. Change how a cache line is fetched. Update to work with caches. Also have separate functions for different behavior if squash is coming from decode vs commit. cpu/beta_cpu/free_list.hh: Remove some old comments. cpu/beta_cpu/full_cpu.cc: cpu/beta_cpu/full_cpu.hh: Added function to remove instructions from back of instruction list until a certain sequence number. cpu/beta_cpu/iew.hh: Stats, separate squashing behavior due to branches vs memory. cpu/beta_cpu/iew_impl.hh: Stats, separate squashing behavior for branches vs memory. cpu/beta_cpu/inst_queue.cc: Debug stuff cpu/beta_cpu/inst_queue.hh: Stats, change how mem dep unit works, debug stuff cpu/beta_cpu/inst_queue_impl.hh: Stats, change how mem dep unit works, debug stuff. Also add in parameters that used to be hardcoded. cpu/beta_cpu/mem_dep_unit.hh: cpu/beta_cpu/mem_dep_unit_impl.hh: Add in stats, change how memory dependence unit works. It now holds the memory instructions that are waiting for their memory dependences to resolve. It provides which instructions are ready directly to the IQ. cpu/beta_cpu/regfile.hh: Fix up sanity checks. cpu/beta_cpu/rename_map.cc: Fix loop variable type. cpu/beta_cpu/rob_impl.hh: Remove intermediate DynInstPtr cpu/beta_cpu/store_set.cc: Add in debugging statements. cpu/beta_cpu/store_set.hh: Reorder function arguments to match the rest of the calls. --HG-- extra : convert_revision : aabf9b1fecd1d743265dfc3b174d6159937c6f44
247 lines
6.8 KiB
C++
247 lines
6.8 KiB
C++
|
|
#include "cpu/beta_cpu/bpred_unit.hh"
|
|
#include "base/traceflags.hh"
|
|
#include "base/trace.hh"
|
|
|
|
template<class Impl>
|
|
TwobitBPredUnit<Impl>::TwobitBPredUnit(Params ¶ms)
|
|
: BP(params.local_predictor_size,
|
|
params.local_ctr_bits,
|
|
params.instShiftAmt),
|
|
BTB(params.BTBEntries,
|
|
params.BTBTagSize,
|
|
params.instShiftAmt),
|
|
RAS(params.RASSize)
|
|
{
|
|
}
|
|
|
|
template <class Impl>
|
|
void
|
|
TwobitBPredUnit<Impl>::regStats()
|
|
{
|
|
lookups
|
|
.name(name() + ".BPredUnit.lookups")
|
|
.desc("Number of BP lookups")
|
|
;
|
|
|
|
condPredicted
|
|
.name(name() + ".BPredUnit.condPredicted")
|
|
.desc("Number of conditional branches predicted")
|
|
;
|
|
|
|
condIncorrect
|
|
.name(name() + ".BPredUnit.condIncorrect")
|
|
.desc("Number of conditional branches incorrect")
|
|
;
|
|
|
|
BTBLookups
|
|
.name(name() + ".BPredUnit.BTBLookups")
|
|
.desc("Number of BTB lookups")
|
|
;
|
|
|
|
BTBHits
|
|
.name(name() + ".BPredUnit.BTBHits")
|
|
.desc("Number of BTB hits")
|
|
;
|
|
|
|
BTBCorrect
|
|
.name(name() + ".BPredUnit.BTBCorrect")
|
|
.desc("Number of correct BTB predictions (this stat may not "
|
|
"work properly.")
|
|
;
|
|
|
|
usedRAS
|
|
.name(name() + ".BPredUnit.usedRAS")
|
|
.desc("Number of times the RAS was used.")
|
|
;
|
|
|
|
RASIncorrect
|
|
.name(name() + ".BPredUnit.RASInCorrect")
|
|
.desc("Number of incorrect RAS predictions.")
|
|
;
|
|
}
|
|
|
|
template <class Impl>
|
|
bool
|
|
TwobitBPredUnit<Impl>::predict(DynInstPtr &inst, Addr &PC)
|
|
{
|
|
// See if branch predictor predicts taken.
|
|
// If so, get its target addr either from the BTB or the RAS.
|
|
// Once that's done, speculatively update the predictor?
|
|
// Save off record of branch stuff so the RAS can be fixed
|
|
// up once it's done.
|
|
|
|
bool pred_taken = false;
|
|
Addr target;
|
|
|
|
++lookups;
|
|
|
|
if (inst->isUncondCtrl()) {
|
|
DPRINTF(Fetch, "BranchPred: Unconditional control.\n");
|
|
pred_taken = true;
|
|
} else {
|
|
++condPredicted;
|
|
|
|
pred_taken = BPLookup(PC);
|
|
|
|
DPRINTF(Fetch, "BranchPred: Branch predictor predicted %i for PC %#x"
|
|
"\n", pred_taken, inst->readPC());
|
|
}
|
|
|
|
PredictorHistory predict_record(inst->seqNum, PC, pred_taken);
|
|
|
|
// Now lookup in the BTB or RAS.
|
|
if (pred_taken) {
|
|
if (inst->isReturn()) {
|
|
++usedRAS;
|
|
|
|
// If it's a function return call, then look up the address
|
|
// in the RAS.
|
|
target = RAS.top();
|
|
|
|
// Record the top entry of the RAS, and its index.
|
|
predict_record.usedRAS = true;
|
|
predict_record.RASIndex = RAS.topIdx();
|
|
predict_record.RASTarget = target;
|
|
|
|
RAS.pop();
|
|
|
|
DPRINTF(Fetch, "BranchPred: Instruction %#x is a return, RAS "
|
|
"predicted target: %#x, RAS index: %i.\n",
|
|
inst->readPC(), target, predict_record.RASIndex);
|
|
} else {
|
|
++BTBLookups;
|
|
|
|
if (inst->isCall()) {
|
|
RAS.push(PC+sizeof(MachInst));
|
|
|
|
// Record that it was a call so that the top RAS entry can
|
|
// be popped off if the speculation is incorrect.
|
|
predict_record.wasCall = true;
|
|
|
|
DPRINTF(Fetch, "BranchPred: Instruction %#x was a call, "
|
|
"adding %#x to the RAS.\n",
|
|
inst->readPC(), PC+sizeof(MachInst));
|
|
}
|
|
|
|
if (BTB.valid(PC)) {
|
|
++BTBHits;
|
|
|
|
//If it's anything else, use the BTB to get the target addr.
|
|
target = BTB.lookup(PC);
|
|
|
|
DPRINTF(Fetch, "BranchPred: Instruction %#x predicted target "
|
|
"is %#x.\n", inst->readPC(), target);
|
|
|
|
} else {
|
|
DPRINTF(Fetch, "BranchPred: BTB doesn't have a valid entry."
|
|
"\n");
|
|
pred_taken = false;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
if (pred_taken) {
|
|
// Set the PC and the instruction's predicted target.
|
|
PC = target;
|
|
inst->setPredTarg(target);
|
|
} else {
|
|
PC = PC + sizeof(MachInst);
|
|
inst->setPredTarg(PC);
|
|
}
|
|
|
|
predHist.push_front(predict_record);
|
|
|
|
assert(!predHist.empty());
|
|
|
|
return pred_taken;
|
|
}
|
|
|
|
template <class Impl>
|
|
void
|
|
TwobitBPredUnit<Impl>::update(const InstSeqNum &done_sn)
|
|
{
|
|
DPRINTF(Fetch, "BranchPred: Commiting branches until sequence number "
|
|
"%i.\n", done_sn);
|
|
|
|
while (!predHist.empty() && predHist.back().seqNum <= done_sn) {
|
|
assert(!predHist.empty());
|
|
|
|
// Update the branch predictor with the correct results of branches.
|
|
BP.update(predHist.back().PC, predHist.back().predTaken);
|
|
|
|
predHist.pop_back();
|
|
}
|
|
}
|
|
|
|
template <class Impl>
|
|
void
|
|
TwobitBPredUnit<Impl>::squash(const InstSeqNum &squashed_sn)
|
|
{
|
|
while (!predHist.empty() && predHist.front().seqNum > squashed_sn) {
|
|
if (predHist.front().usedRAS) {
|
|
DPRINTF(Fetch, "BranchPred: Restoring top of RAS to: %i, "
|
|
"target: %#x.\n",
|
|
predHist.front().RASIndex,
|
|
predHist.front().RASTarget);
|
|
|
|
RAS.restore(predHist.front().RASIndex,
|
|
predHist.front().RASTarget);
|
|
} else if (predHist.front().wasCall) {
|
|
DPRINTF(Fetch, "BranchPred: Removing speculative entry added "
|
|
"to the RAS.\n");
|
|
|
|
RAS.pop();
|
|
}
|
|
|
|
predHist.pop_front();
|
|
}
|
|
}
|
|
|
|
template <class Impl>
|
|
void
|
|
TwobitBPredUnit<Impl>::squash(const InstSeqNum &squashed_sn,
|
|
const Addr &corr_target,
|
|
const bool actually_taken)
|
|
{
|
|
// Now that we know that a branch was mispredicted, we need to undo
|
|
// all the branches that have been seen up until this branch and
|
|
// fix up everything.
|
|
|
|
++condIncorrect;
|
|
|
|
DPRINTF(Fetch, "BranchPred: Squashing from sequence number %i, "
|
|
"setting target to %#x.\n",
|
|
squashed_sn, corr_target);
|
|
|
|
while (!predHist.empty() && predHist.front().seqNum > squashed_sn) {
|
|
|
|
if (predHist.front().usedRAS) {
|
|
DPRINTF(Fetch, "BranchPred: Restoring top of RAS to: %i, "
|
|
"target: %#x.\n",
|
|
predHist.front().RASIndex,
|
|
predHist.front().RASTarget);
|
|
|
|
RAS.restore(predHist.front().RASIndex,
|
|
predHist.front().RASTarget);
|
|
} else if (predHist.front().wasCall) {
|
|
DPRINTF(Fetch, "BranchPred: Removing speculative entry added "
|
|
"to the RAS.\n");
|
|
|
|
RAS.pop();
|
|
}
|
|
|
|
predHist.pop_front();
|
|
}
|
|
|
|
predHist.front().predTaken = actually_taken;
|
|
|
|
if (predHist.front().usedRAS) {
|
|
++RASIncorrect;
|
|
}
|
|
|
|
BP.update(predHist.front().PC, actually_taken);
|
|
|
|
BTB.update(predHist.front().PC, corr_target);
|
|
}
|