Use PHR in ITTAGE (#628)

* cpu-o3: use phr in ittage

Change-Id: Id57fceb89d8e89791cfaa5e31f0321fc07f4b1a9

* cpu-o3: fix PHR type miss in ittage

Change-Id: I82a46832bae8466ca27136d3633fa67224ddc5c2

* cpu-o3: update `doUpdateHist` function doc in ittage

Change-Id: I5c990086b68d69cac3e6fb49e7596b52fa6633b8

* cpu-o3: check fold history for ittage

Change-Id: I269cf140d83fa2593f92c4a6e580037faefba688

Author: Yakkhini

src/cpu/pred/BranchPredictor.py

@@ -1076,6 +1076,7 @@ class BTBITTAGE(TimedBaseBTBPredictor):
     cxx_class = 'gem5::branch_prediction::btb_pred::BTBITTAGE'
     cxx_header = "cpu/pred/btb/btb_ittage.hh"
 
+    needMoreHistories = Param.Bool(True, "BTBITTAGE needs more histories")
     numPredictors = Param.Unsigned(5, "Number of TAGE predictors")
     tableSizes = VectorParam.Unsigned([256]*2 + [512]*3, "the ITTAGE T0~Tn length")
     TTagBitSizes = VectorParam.Unsigned([9]*5, "the T0~Tn entry's tag bit size")

src/cpu/pred/SConscript

@@ -127,6 +127,7 @@ DebugFlag('TAGE')
 DebugFlag('TAGEUseful')
 DebugFlag('TAGEHistory')
 DebugFlag('ITTAGE')
+DebugFlag('ITTAGEHistory')
 DebugFlag('FoldedHist')
 DebugFlag('RAS')
 DebugFlag('MGSC')

src/cpu/pred/btb/btb_ittage.cc

@@ -12,6 +12,7 @@
 #include "debug/DecoupleBPVerbose.hh"
 #include "debug/DecoupleBPUseful.hh"
 #include "debug/ITTAGE.hh"
+#include "debug/ITTAGEHistory.hh"
 
 namespace gem5 {
 
@@ -30,6 +31,7 @@ maxHistLen(p.maxHistLen),
 numTablesToAlloc(p.numTablesToAlloc),
 ittageStats(this, p.numPredictors)
 {
+    this->needMoreHistories = p.needMoreHistories;
     DPRINTF(ITTAGE, "BTBITTAGE constructor numBr=%d\n", numBr);
     tageTable.resize(numPredictors);
     tableIndexBits.resize(numPredictors);
@@ -51,9 +53,9 @@ ittageStats(this, p.numPredictors)
 
         assert(tablePcShifts.size() >= numPredictors);
 
-        tagFoldedHist.push_back(GlobalFoldedHist((int)histLengths[i], (int)tableTagBits[i], (int)16));
-        altTagFoldedHist.push_back(GlobalFoldedHist((int)histLengths[i], (int)tableTagBits[i]-1, (int)16));
-        indexFoldedHist.push_back(GlobalFoldedHist((int)histLengths[i], (int)tableIndexBits[i], (int)16));
+        tagFoldedHist.push_back(PathFoldedHist((int)histLengths[i], (int)tableTagBits[i], (int)16));
+        altTagFoldedHist.push_back(PathFoldedHist((int)histLengths[i], (int)tableTagBits[i]-1, (int)16));
+        indexFoldedHist.push_back(PathFoldedHist((int)histLengths[i], (int)tableIndexBits[i], (int)16));
     }
     // useAlt.resize(128);
     // for (unsigned i = 0; i < useAlt.size(); ++i) {
@@ -451,50 +453,84 @@ BTBITTAGE::satDecrement(int min, short &counter)
     return counter == min;
 }
 
+/**
+ * @brief Updates branch history for speculative execution
+ *
+ * This function updates three types of folded histories:
+ * - Tag folded history: Used for tag computation
+ * - Alternative tag folded history: Used for alternative tag computation
+ * - Index folded history: Used for table index computation
+ *
+ * @param history The current branch history
+ * @param taken Whether the branch was taken
+ * @param pc The program counter of the branch
+ * @param target The target address of the branch
+ */
 void
-BTBITTAGE::doUpdateHist(const boost::dynamic_bitset<> &history, int shamt, bool taken)
+BTBITTAGE::doUpdateHist(const boost::dynamic_bitset<> &history, bool taken, Addr pc, Addr target)
 {
-    if (debugFlag) {
+    if (debug::ITTAGEHistory) {  // if debug flag is off, do not use to_string since it's too slow
         std::string buf;
         boost::to_string(history, buf);
-        DPRINTF(ITTAGE, "in doUpdateHist, shamt %d, taken %d, history %s\n", shamt, taken, buf);
+        DPRINTF(ITTAGEHistory, "in doUpdateHist, taken %d, pc %#lx, history %s\n", taken, pc, buf.c_str());
     }
-    if (shamt == 0) {
-        DPRINTF(ITTAGE, "shamt is 0, returning\n");
+    if (!taken) {
+        DPRINTF(ITTAGEHistory, "not updating folded history, since FB not taken\n");
         return;
     }
 
     for (int t = 0; t < numPredictors; t++) {
         for (int type = 0; type < 3; type++) {
-            DPRINTF(ITTAGE, "t: %d, type: %d\n", t, type);
-
             auto &foldedHist = type == 0 ? indexFoldedHist[t] : type == 1 ? tagFoldedHist[t] : altTagFoldedHist[t];
-            foldedHist.update(history, shamt, taken);
+            // since we have folded path history, we can put arbitrary shamt here, and it wouldn't make a difference
+            foldedHist.update(history, 2, taken, pc, target);
+            DPRINTF(ITTAGEHistory, "t: %d, type: %d, foldedHist _folded 0x%lx\n", t, type, foldedHist.get());
         }
     }
 }
 
+/**
+ * @brief Updates branch history for speculative execution
+ *
+ * This function updates the branch history for speculative execution
+ * based on the provided history and prediction information.
+ *
+ * It first retrieves the history information from the prediction metadata
+ * and then calls the doUpdateHist function to update the folded histories.
+ *
+ * @param history The current branch history
+ * @param pred The prediction metadata containing history information
+ */
 void
-BTBITTAGE::specUpdateHist(const boost::dynamic_bitset<> &history, FullBTBPrediction &pred)
+BTBITTAGE::specUpdatePHist(const boost::dynamic_bitset<> &history, FullBTBPrediction &pred)
 {
-    int shamt;
-    bool cond_taken;
-    std::tie(shamt, cond_taken) = pred.getHistInfo();
-    doUpdateHist(history, shamt, cond_taken);
+    auto [pc, target, taken] = pred.getPHistInfo();
+    doUpdateHist(history, taken, pc, target);
 }
 
+/**
+ * @brief Recovers branch history state after a misprediction
+ *
+ * This function:
+ * 1. Restores the folded histories from the saved metadata
+ * 2. Updates the histories with the correct branch outcome
+ * 3. Ensures predictor state is consistent after recovery
+ *
+ * @param history The branch history to recover to
+ * @param entry The fetch stream entry containing recovery information
+ * @param shamt Number of bits to shift in history update
+ * @param cond_taken The actual branch outcome
+ */
 void
-BTBITTAGE::recoverHist(const boost::dynamic_bitset<> &history,
-    const FetchStream &entry, int shamt, bool cond_taken)
+BTBITTAGE::recoverPHist(const boost::dynamic_bitset<> &history, const FetchStream &entry, int shamt, bool cond_taken)
 {
-    // TODO: need to get idx
     std::shared_ptr<TageMeta> predMeta = std::static_pointer_cast<TageMeta>(entry.predMetas[getComponentIdx()]);
     for (int i = 0; i < numPredictors; i++) {
         tagFoldedHist[i].recover(predMeta->tagFoldedHist[i]);
         altTagFoldedHist[i].recover(predMeta->altTagFoldedHist[i]);
         indexFoldedHist[i].recover(predMeta->indexFoldedHist[i]);
     }
-    doUpdateHist(history, shamt, cond_taken);
+    doUpdateHist(history, cond_taken, entry.getControlPC(), entry.getTakenTarget());
 }
 
 void

src/cpu/pred/btb/btb_ittage.hh

@@ -100,9 +100,14 @@ class BTBITTAGE : public TimedBaseBTBPredictor
 
     std::shared_ptr<void> getPredictionMeta() override;
 
-    void specUpdateHist(const boost::dynamic_bitset<> &history, FullBTBPrediction &pred) override;
+    // speculative update 3 folded history, according history and pred.taken
+    // the other specUpdateHist methods are left blank
+    void specUpdatePHist(const boost::dynamic_bitset<> &history, FullBTBPrediction &pred) override;
 
-    void recoverHist(const boost::dynamic_bitset<> &history, const FetchStream &entry, int shamt, bool cond_taken) override;
+    // Recover 3 folded history after a misprediction, then update 3 folded history according to history and pred.taken
+    // the other recoverHist methods are left blank
+    void recoverPHist(const boost::dynamic_bitset<> &history,
+                        const FetchStream &entry,int shamt, bool cond_taken) override;
 
     void update(const FetchStream &entry) override;
 
@@ -132,7 +137,9 @@ class BTBITTAGE : public TimedBaseBTBPredictor
         return (pc & (blockSize - 1)) >> 1;
     }
 
-    void doUpdateHist(const bitset &history, int shamt, bool taken);
+    // Update branch history
+    void doUpdateHist(const bitset &history, bool taken, Addr pc, Addr target);
+
 
     const unsigned numPredictors;
 
@@ -144,9 +151,9 @@ class BTBITTAGE : public TimedBaseBTBPredictor
     std::vector<bitset> tableTagMasks;
     std::vector<unsigned> tablePcShifts;
     std::vector<unsigned> histLengths;
-    std::vector<GlobalFoldedHist> tagFoldedHist;
-    std::vector<GlobalFoldedHist> altTagFoldedHist;
-    std::vector<GlobalFoldedHist> indexFoldedHist;
+    std::vector<PathFoldedHist> tagFoldedHist;
+    std::vector<PathFoldedHist> altTagFoldedHist;
+    std::vector<PathFoldedHist> indexFoldedHist;
 
     LFSR64 allocLFSR;
 
@@ -218,12 +225,12 @@ class BTBITTAGE : public TimedBaseBTBPredictor
     {
         std::unordered_map<Addr, TagePrediction> preds;
         bitset usefulMask;
-        std::vector<GlobalFoldedHist> tagFoldedHist;
-        std::vector<GlobalFoldedHist> altTagFoldedHist;
-        std::vector<GlobalFoldedHist> indexFoldedHist;
+        std::vector<PathFoldedHist> tagFoldedHist;
+        std::vector<PathFoldedHist> altTagFoldedHist;
+        std::vector<PathFoldedHist> indexFoldedHist;
         TageMeta(std::unordered_map<Addr, TagePrediction> preds, bitset usefulMask,
-                 std::vector<GlobalFoldedHist> tagFoldedHist, std::vector<GlobalFoldedHist> altTagFoldedHist,
-                 std::vector<GlobalFoldedHist> indexFoldedHist)
+                 std::vector<PathFoldedHist> tagFoldedHist, std::vector<PathFoldedHist> altTagFoldedHist,
+                 std::vector<PathFoldedHist> indexFoldedHist)
             : preds(preds),
               usefulMask(usefulMask),
               tagFoldedHist(tagFoldedHist),

src/cpu/pred/btb/decoupled_bpred.cc

@@ -1150,6 +1150,9 @@ DecoupledBPUWithBTB::updateHistoryForPrediction(FetchStream &entry)
     if (tage->isEnabled()) {
         tage->checkFoldedHist(s0PHistory, "speculative update");
     }
+    if (ittage->isEnabled()) {
+        ittage->checkFoldedHist(s0PHistory, "speculative update");
+    }
     if (microtage->isEnabled()) {
         microtage->checkFoldedHist(s0PHistory, "speculative update");
     }
@@ -1241,6 +1244,11 @@ DecoupledBPUWithBTB::recoverHistoryForSquash(
             squash_type == SQUASH_CTRL ? "control squash" :
             squash_type == SQUASH_OTHER ? "non control squash" : "trap squash");
     }
+    if (ittage->isEnabled()) {
+        ittage->checkFoldedHist(s0PHistory,
+            squash_type == SQUASH_CTRL ? "control squash" :
+            squash_type == SQUASH_OTHER ? "non control squash" : "trap squash");
+    }
     if (microtage->isEnabled()) {
         microtage->checkFoldedHist(s0PHistory,
             squash_type == SQUASH_CTRL ? "control squash" :