cpu-o3:Implement predwrongSource method (#683)

* cpu-o3:Implement predwrongSource method

Change-Id: If763f1cc4fd54da740fde677d0ded7801ecee023

* cpu-o3: update source handling in BTBEntry and prediction logic

Change-Id: I78091441671e564579c3e81f06daf51414a095fc

* cpu-o3: add statistic for wrong predictions in uBTB

Change-Id: I787f662435b5ab49b0f7103f7d9b7fbecbcfe270

* cpu-o3: align source handling in BTB entries and update prediction statistics

* cpu-o3: align formatting in BTB entry handling

Change-Id: Ie89cd4a5eeb41ce8347eb013402ef823c697626e

* cpu-o3: remove unnecessary assertion for wrong branch source

Change-Id: Ieab9cfbd9c70c0b5cc7885c39fc313eeaac9717a

* cpu-o3: correct delay condition and update fallthrough statistics

Change-Id: Ied49f642bc88a6be31bdf51d3f6de608f8661910

* cpu-o3: add handling for wrong source predictions in commit

Change-Id: I9d8c591468d5af33145f58ff80762ae95c69840e

* cpu-o3: removing unused s3Source in prediction structures

Change-Id: I39d8808a2c9467f5362739623a09433e7a1559df

* cpu-o3: align source prediction handling across multiple componen

Change-Id: I9ccb31f8e110c4ba13d53aad7dd3bbdbd6ba9358

* cpu-o3: remove predwrongSource methods and associated statistics from various predictors

* cpu-o3: enhance source prediction alignment

Change-Id: Ic8a5757f4f87dbaf448df998fcd714e46f80d9a8

* cpu-o3:  use const references

Change-Id: If8e15a0d38292a384106d88d8495b06cb6ea1589

---------

Co-authored-by: Cao Jiaming <caojiaming@bosc.ac.cn>

Author: CaoJiaming776

src/cpu/pred/btb/abtb.cc

@@ -213,16 +213,22 @@ AheadBTB::fillStagePredictions(const std::vector<TickedBTBEntry>& entries,
         ubtb_pred_entry = stagePreds[0].btbEntries[0];
         assert(ubtb_pred_entry.valid);
         mixed_entries = entries;
+        for (auto &entry : mixed_entries) {
+            if (entry.pc == ubtb_pred_entry.pc) {
+                entry.valid = false; // invalidate duplicated entry from aBTB (only use for align counter)
+                break;
+            }
+        }
         mixed_entries.push_back(TickedBTBEntry(ubtb_pred_entry, curTick()));
         // Deduplicate entries by pc (order can change)
         std::sort(mixed_entries.begin(), mixed_entries.end(),
               [](const TickedBTBEntry& a, const TickedBTBEntry& b) {
                   return a.pc < b.pc;
               });
-        // Remove duplicates
-        mixed_entries.erase(std::unique(mixed_entries.begin(), mixed_entries.end(),
-              [](const TickedBTBEntry& a, const TickedBTBEntry& b) {
-                  return a.pc == b.pc;
+        // Drop entries invalidated during deduplication above
+        mixed_entries.erase(std::remove_if(mixed_entries.begin(), mixed_entries.end(),
+              [](const TickedBTBEntry& entry) {
+                  return !entry.valid;
               }),
               mixed_entries.end());
         // return;
@@ -596,6 +602,7 @@ AheadBTB::updateUsingS3Pred(FullBTBPrediction &s3Pred, const Addr previousPC)
         BranchInfo takenbranchinfo;
         takenbranchinfo.pc = s3Pred.getTakenEntry().pc;
         takenbranchinfo.target = s3Pred.getTakenEntry().target;
+        entry.source = getComponentIdx(); // mark the entry source as AheadBTB
 
         updateBTBEntry(btb_idx, btb_tag, entry, takenbranchinfo, s3Pred.isTaken());
     }
@@ -671,6 +678,7 @@ AheadBTB::update(const FetchStream &stream)
             return;
         }
         Addr btb_idx = getIndex(previousPC);  // use last pc to get idx
+        entry.source = getComponentIdx(); // mark the entry source as AheadBTB
         updateBTBEntry(btb_idx, btb_tag, entry, stream.exeBranchInfo, stream.exeTaken);
     }
 }
@@ -700,7 +708,9 @@ AheadBTB::getPreviousPC(const FetchStream &stream)
     }
 }
 
+
 #ifndef UNIT_TEST
+
 void
 AheadBTB::commitBranch(const FetchStream &stream, const DynInstPtr &inst)
 {

src/cpu/pred/btb/btb_ittage.cc

@@ -149,7 +149,6 @@ BTBITTAGE::lookupHelper(Addr startAddr, const std::vector<BTBEntry> &btbEntries,
                 ittageStats.predTableHits.sample(main_info.table, 1);
             }
             // Note: predTargetHit will be updated in the update phase when we know the actual target
-
             TagePrediction pred(btb_entry.pc, main_info, alt_info, use_alt, main_target);
             meta->preds[btb_entry.pc] = pred;
         }
@@ -501,6 +500,21 @@ BTBITTAGE::doUpdateHist(const boost::dynamic_bitset<> &history, bool taken, Addr
     }
 }
 
+bool
+BTBITTAGE::tageHit()
+{
+    auto meta = getPredictionMeta();
+    auto preds = std::static_pointer_cast<TageMeta>(meta)->preds;
+    bool hit = false;
+    for (auto & [pc, pred] : preds) {
+        if (pred.mainInfo.found) {
+            hit = true;
+            break;
+        }
+    }
+    return hit;
+}
+
 /**
  * @brief Updates branch history for speculative execution
  *

src/cpu/pred/btb/btb_ittage.hh

@@ -141,7 +141,6 @@ class BTBITTAGE : public TimedBaseBTBPredictor
     // Update branch history
     void doUpdateHist(const bitset &history, bool taken, Addr pc, Addr target);
 
-
     const unsigned numPredictors;
 
     std::vector<unsigned> tableSizes;
@@ -271,6 +270,7 @@ public:
     bool debugFlag = false;
 
     void recoverFoldedHist(const bitset& history);
+    bool tageHit();
 
     // void checkFoldedHist(const bitset& history);
 };

src/cpu/pred/btb/btb_tage.cc

@@ -1130,6 +1130,7 @@ BTBTAGE::getLRUVictim(int table, Addr index)
 }
 
 #ifndef UNIT_TEST
+
 void
 BTBTAGE::commitBranch(const FetchStream &stream, const DynInstPtr &inst)
 {

src/cpu/pred/btb/btb_tage.hh

@@ -101,12 +101,13 @@ class BTBTAGE : public TimedBaseBTBPredictor
             bool taken;            // Final prediction (taken/not taken) = use_alt ? alt_provided ? alt_taken : base_taken : main_taken
             bool altPred;          // Alternative prediction = alt_provided ? alt_taken : base_taken;
 
+
             TagePrediction() : btb_pc(0), useAlt(false), taken(false), altPred(false) {}
 
             TagePrediction(Addr btb_pc, TageTableInfo mainInfo, TageTableInfo altInfo,
                             bool useAlt, bool taken, bool altPred) :
                             btb_pc(btb_pc), mainInfo(mainInfo), altInfo(altInfo),
-                            useAlt(useAlt), taken(taken), altPred(altPred) {}
+                            useAlt(useAlt), taken(taken), altPred(altPred){}
     };
 
 
@@ -374,6 +375,8 @@ class BTBTAGE : public TimedBaseBTBPredictor
         Scalar predHit;
         Scalar predMiss;
 
+        Scalar s3PredwrongTage;
+
         int bankIdx;
         int numPredictors;
         int numBanks;

src/cpu/pred/btb/btb_ubtb.cc

@@ -212,6 +212,7 @@ UBTB::updateUsingS3Pred(FullBTBPrediction &s3Pred)
     }
     auto startAddr = s3Pred.bbStart;
     UBTBIter oldEntryIter = lastPred.hit_entry;
+    takenEntry.source = getComponentIdx();
     updateNewEntry(oldEntryIter, takenEntry, startAddr);
 
 }

src/cpu/pred/btb/decoupled_bpred.cc

@@ -182,7 +182,6 @@ DecoupledBPUWithBTB::tick()
         bpuState = BpuState::IDLE;
     }
 
-
     // Decrement override bubbles counter
     if (numOverrideBubbles > 0) {
         numOverrideBubbles--;
@@ -246,6 +245,53 @@ DecoupledBPUWithBTB::generateFinalPredAndCreateBubbles()
     // Store the chosen prediction as our final prediction
     finalPred = *chosenPrediction;
 
+    finalPred.s1Source = -1;//meaning fallthrough
+    finalPred.s3Source = -1;
+
+    if (predsOfEachStage[0].btbEntries.size() != 0) {
+        for (auto entry : predsOfEachStage[0].btbEntries){
+            if (entry.isIndirect || entry.isDirect || entry.ctr >= 0 ||entry.alwaysTaken){
+                finalPred.s1Source = entry.source;
+                break;
+            }
+        }
+    }
+
+    bool found_s3_taken = false;
+    bool na_s3_taken_but_have_cond = false;
+
+    for (BTBEntry entry : predsOfEachStage[2].btbEntries) {
+        if (entry.isDirect || entry.isIndirect || entry.ctr >= 0 || entry.alwaysTaken) {
+            found_s3_taken = true;
+        }else if (entry.isCond){
+            //only use when there's no taken prediction in s3
+            na_s3_taken_but_have_cond = true;
+        }
+    }
+
+    if (found_s3_taken) {
+        auto pred_taken_entry = finalPred.getTakenEntry();
+        if (pred_taken_entry.valid) {
+            if (pred_taken_entry.isReturn) {
+                finalPred.s3Source = ras->getComponentIdx();
+            } else if (pred_taken_entry.isIndirect && ittage->tageHit()) {
+                finalPred.s3Source = ittage->getComponentIdx();
+            }else if (pred_taken_entry.isCond) {
+                finalPred.s3Source = tage->getComponentIdx();
+            } else {
+                finalPred.s3Source = mbtb->getComponentIdx();
+            }
+        }else {
+            if (na_s3_taken_but_have_cond) {
+                finalPred.s3Source = tage->getComponentIdx();
+            }else {
+                finalPred.s3Source = -1;
+            }
+        }
+    }
+
+
+
     // 3. Calculate override bubbles needed for pipeline consistency
     // Override bubbles are needed when earlier stages predict differently from later stages
     unsigned first_hit_stage = 0;
@@ -1011,6 +1057,9 @@ DecoupledBPUWithBTB::createFetchStreamEntry()
     entry.predSource = finalPred.predSource;
     entry.overrideReason = finalPred.overrideReason;
 
+    entry.s1Source = finalPred.s1Source;
+    entry.s3Source = finalPred.s3Source;
+
     // Save predictors' metadata
     for (int i = 0; i < numComponents; i++) {
         entry.predMetas[i] = components[i]->getPredictionMeta();

src/cpu/pred/btb/decoupled_bpred.hh

@@ -316,6 +316,7 @@ class DecoupledBPUWithBTB : public BPredUnit
         // Fine-grained branch classification statistics
         statistics::Vector branchClassCounts; ///< Classified branch occurrences
         statistics::Vector branchClassMisses; ///< Mispredictions per class
+        statistics::Scalar branchClassCountsTotal; ///< Total classified branches
         statistics::Vector controlSquashByClass; ///< Commit/Resolve-path squashes per class
 
         // Branch coverage statistics
@@ -368,6 +369,14 @@ class DecoupledBPUWithBTB : public BPredUnit
         // Window blocking statistics
         statistics::Scalar predictionBlockedForUpdate;  // Times prediction was blocked for update priority
 
+        statistics::Scalar s1PredWrongFallthrough;
+        statistics::Scalar s1PredWrongUbtb;
+        statistics::Scalar s1PredWrongAbtb;
+        statistics::Scalar s3PredWrongMbtb;
+        statistics::Scalar s3PredWrongTage;
+        statistics::Scalar s3PredWrongIttage;
+        statistics::Scalar s3PredWrongRas;
+
         DBPBTBStats(statistics::Group* parent, unsigned numStages, unsigned fsqSize, unsigned maxInstsNum);
     } dbpBtbStats;
 
@@ -908,6 +917,9 @@ class DecoupledBPUWithBTB : public BPredUnit
      */
     void commitBranch(const DynInstPtr &inst, bool miss);
 
+
+    void commitPredWrongSource(const FetchStream &entry);
+
     /**
      * @brief Process branch misprediction, determine type and update statistics
      *

src/cpu/pred/btb/decoupled_bpred_stats.cc

@@ -454,6 +454,7 @@ DecoupledBPUWithBTB::DBPBTBStats::DBPBTBStats(
     ADD_STAT(otherMiss, statistics::units::Count::get(), "the number of other branch misses"),
     ADD_STAT(branchClassCounts, statistics::units::Count::get(), "branch counts by fine-grained class"),
     ADD_STAT(branchClassMisses, statistics::units::Count::get(), "branch mispredictions by fine-grained class"),
+    ADD_STAT(branchClassCountsTotal, statistics::units::Count::get(), "total number of classified branches"),
     ADD_STAT(controlSquashByClass, statistics::units::Count::get(), "commit/resolve-path squashes by branch class"),
     ADD_STAT(staticBranchNum, statistics::units::Count::get(), "the number of all (different) static branches"),
     ADD_STAT(staticBranchNumEverTaken, statistics::units::Count::get(), "the number of all (different) static branches that are once taken"),
@@ -497,7 +498,15 @@ DecoupledBPUWithBTB::DBPBTBStats::DBPBTBStats(
     ADD_STAT(btbEntriesWithOnlyOneJump, statistics::units::Count::get(), "number of btb entries with different start PC starting with a jump"),
     ADD_STAT(predFalseHit, statistics::units::Count::get(), "false hit detected at pred"),
     ADD_STAT(commitFalseHit, statistics::units::Count::get(), "false hit detected at commit"),
-    ADD_STAT(predictionBlockedForUpdate, statistics::units::Count::get(), "prediction blocked for update priority")
+    ADD_STAT(predictionBlockedForUpdate, statistics::units::Count::get(), "prediction blocked for update priority"),
+    ADD_STAT(s1PredWrongFallthrough, statistics::units::Count::get(), "S1pred wrong full throughs"),
+    ADD_STAT(s1PredWrongUbtb, statistics::units::Count::get(),"S1pred wrong using ubtb "),
+    ADD_STAT(s1PredWrongAbtb, statistics::units::Count::get(), "S1pred wrong using abtb "),
+    ADD_STAT(s3PredWrongMbtb, statistics::units::Count::get(), "S3pred wrong blame mbtb "),
+    ADD_STAT(s3PredWrongTage, statistics::units::Count::get(), "S3pred wrong blame tage "),
+    ADD_STAT(s3PredWrongIttage, statistics::units::Count::get(), "S3pred wrong blame ittage "),
+    ADD_STAT(s3PredWrongRas, statistics::units::Count::get(), "S3pred wrong blame ras ")
+
 {
     predsOfEachStage.init(numStages);
     commitPredsFromEachStage.init(numStages+1);
@@ -700,6 +709,7 @@ DecoupledBPUWithBTB::addBranchClassStat(BranchClass cls, bool mispred)
     dbpBtbStats.branchClassCounts[idx]++;
     if (mispred) {
         dbpBtbStats.branchClassMisses[idx]++;
+        dbpBtbStats.branchClassCountsTotal++;
     }
 
     DPRINTF(DBPBTBStats, "Branch classified as %s, mispred=%d\n",
@@ -859,9 +869,82 @@ DecoupledBPUWithBTB::commitBranch(const DynInstPtr &inst, bool mispred)
     for (auto component : components) {
         component->commitBranch(entry, inst);
     }
+    //here add final counter
+
+    if (mispred) {
+        commitPredWrongSource(entry);
+    }
+
 }
 
+void
+DecoupledBPUWithBTB::commitPredWrongSource(const FetchStream &entry)
+{
+    int ubtbid = ubtb->getComponentIdx();
+    int abtbid = abtb->getComponentIdx();
+    int mbtbid = mbtb->getComponentIdx();
+    int tageid = tage->getComponentIdx();
+    int ittageid = ittage->getComponentIdx();
+    int rasid = ras->getComponentIdx();
+
+    int s1PredSource = entry.s1Source;
+    int s3PredSource = entry.s3Source;
+
+    auto exeBranchInfo = entry.exeBranchInfo;
+
+    bool onlyDirectionWrong = entry.exeTaken != entry.predTaken;
+
+    assert(s1PredSource < mbtbid);
+    if (s1PredSource == ubtbid) {
+        dbpBtbStats.s1PredWrongUbtb++;
+    } else if (s1PredSource == abtbid) {
+        dbpBtbStats.s1PredWrongAbtb++;
+    }else {
+        dbpBtbStats.s1PredWrongFallthrough++;
+    }
 
+    if (s3PredSource == rasid) {
+        if (exeBranchInfo.isCond) {
+            dbpBtbStats.s3PredWrongTage++;
+        } else if (exeBranchInfo.isReturn) {
+            dbpBtbStats.s3PredWrongRas++;
+        } else {
+            dbpBtbStats.s3PredWrongMbtb++;
+        }
+    } else if (s3PredSource == ittageid) {
+        if (exeBranchInfo.isIndirect) {
+            dbpBtbStats.s3PredWrongIttage++;
+        } else if (exeBranchInfo.isCond) {
+            dbpBtbStats.s3PredWrongTage++;
+        } else {
+            dbpBtbStats.s3PredWrongMbtb++;
+        }
+    } else if (s3PredSource == tageid) {
+        if (exeBranchInfo.isCond) {
+            if (onlyDirectionWrong) {
+                dbpBtbStats.s3PredWrongTage++;
+            } else {
+                dbpBtbStats.s3PredWrongMbtb++;
+            }
+        } else {
+            dbpBtbStats.s3PredWrongMbtb++;
+        }
+    }else if (s3PredSource == mbtbid) {
+        if (exeBranchInfo.isCond) {
+            if (onlyDirectionWrong) {
+                dbpBtbStats.s3PredWrongTage++;
+            } else {
+                dbpBtbStats.s3PredWrongMbtb++;
+            }
+        } else if (exeBranchInfo.isIndirect) {
+            dbpBtbStats.s3PredWrongIttage++;
+        } else {
+            dbpBtbStats.s3PredWrongMbtb++;
+        }
+    }else if (s3PredSource == -1) {
+        dbpBtbStats.s3PredWrongMbtb++;
+    }
+}
 /**
  * @brief Handle instruction commits and phase-based statistics
  *

src/cpu/pred/btb/mbtb.cc

@@ -584,7 +584,6 @@ MBTB::buildUpdatedEntry(const BTBEntry& req_entry,
     if (entry_to_write.isIndirect && stream.exeTaken && stream.getControlPC() == entry_to_write.pc) {
         entry_to_write.target = stream.exeBranchInfo.target;
     }
-
     return entry_to_write;
 }
 
@@ -811,6 +810,7 @@ MBTB::insertVictimCache(const TickedBTBEntry& evicted_entry)
 }
 
 #ifndef UNIT_TEST
+
 void
 MBTB::commitBranch(const FetchStream &stream, const DynInstPtr &inst)
 {
@@ -957,8 +957,7 @@ MBTB::BTBStats::BTBStats(statistics::Group* parent, int numWays) :
     ADD_STAT(returnHits, statistics::units::Count::get(), "returns committed that was predicted hit"),
     ADD_STAT(returnMisses, statistics::units::Count::get(), "returns committed that was predicted miss"),
 
-    ADD_STAT(victimCacheHit, statistics::units::Count::get(), "victim cache hits"),
-    ADD_STAT(predHitCount, statistics::units::Count::get(), "number of hit entries encountered on mbtb hit")
+    ADD_STAT(victimCacheHit, statistics::units::Count::get(), "victim cache hits")
 
 {
     predHitCount.init(0, numWays * 2, 1);   // max 4ways * 2(halfAligned) + VC