cpu-o3: add stats for BPU override bubbles and UFTB pred/update

configs/example/xiangshan.py

@@ -349,7 +349,9 @@ def setKmhV3IdealParams(args, system):
             cpu.branchPred.tage.enableSC = False # TODO(bug): When numBr changes, enabling SC will trigger an assert
             cpu.branchPred.ftq_size = 256
             cpu.branchPred.fsq_size = 256
-            cpu.branchPred.uftb.numEntries = 1024
+            uftb_size = 1024
+            cpu.branchPred.uftb.numEntries = uftb_size
+            cpu.branchPred.uftb.numWays = uftb_size
             cpu.branchPred.ftb.numEntries = 16384
             cpu.branchPred.tage.numPredictors = 9
             cpu.branchPred.tage.baseTableSize = 4096

src/cpu/pred/ftb/decoupled_bpred.cc

@@ -449,8 +449,18 @@ DecoupledBPUWithFTB::DBPFTBStats::DBPFTBStats(statistics::Group* parent, unsigne
     ADD_STAT(otherMiss, statistics::units::Count::get(), "the number of other branch misses"),
     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"),
-    ADD_STAT(predsOfEachStage, statistics::units::Count::get(), "the number of preds of each stage that account for final pred"),
-    ADD_STAT(commitPredsFromEachStage, statistics::units::Count::get(), "the number of preds of each stage that account for a committed stream"),
+    ADD_STAT(overrideByL1, statistics::units::Count::get(), "the number of preds override by L1"),
+    ADD_STAT(overrideByL1WhenL0Hit, statistics::units::Count::get(),
+        "the number of preds override by L1, when L0 Hit and L1 Hit"),
+    ADD_STAT(overrideByL1WhenL0Miss, statistics::units::Count::get(),
+        "the number of preds override by L1, when L0 Miss and L1 Hit"),
+    ADD_STAT(overrideByL2, statistics::units::Count::get(), "the number of preds override by L2"),
+    ADD_STAT(squashWhenOverriding, statistics::units::Count::get(), "the number of squash when overriding"),
+    ADD_STAT(overrideBubbles, statistics::units::Count::get(), "number of bpu pred Override Bubbles"),
+    ADD_STAT(predsOfEachStage, statistics::units::Count::get(),
+        "the number of preds of each stage that account for final pred"),
+    ADD_STAT(commitPredsFromEachStage, statistics::units::Count::get(),
+        "the number of preds of each stage that account for a committed stream"),
     ADD_STAT(fsqEntryDist, statistics::units::Count::get(), "the distribution of number of entries in fsq"),
     ADD_STAT(fsqEntryEnqueued, statistics::units::Count::get(), "the number of fsq entries enqueued"),
     ADD_STAT(fsqEntryCommitted, statistics::units::Count::get(), "the number of fsq entries committed at last"),
@@ -610,6 +620,10 @@ DecoupledBPUWithFTB::tick()
         numOverrideBubbles = generateFinalPredAndCreateBubbles();
     }
 
+    if (squashing && numOverrideBubbles > 0 && receivedPred && s0PC != MaxAddr && !sentPCHist) {
+        dbpFtbStats.squashWhenOverriding++;
+    }
+
     if (!squashing) {
         DPRINTF(DecoupleBP, "DecoupledBPUWithFTB::tick()\n");
         DPRINTF(Override, "DecoupledBPUWithFTB::tick()\n");
@@ -650,7 +664,6 @@ DecoupledBPUWithFTB::tick()
         sentPCHist = true;
     }
 
-
     // query loop buffer with start pc
     if (enableLoopBuffer && !lb.isActive() &&
             lb.streamBeforeLoop.getTakenTarget() == lb.streamBeforeLoop.startPC &&
@@ -800,6 +813,7 @@ DecoupledBPUWithFTB::generateFinalPredAndCreateBubbles()
             }
             first_hit_stage++;
         }
+
         // generate bubbles
         bubblesToCreate = first_hit_stage;
         // assign pred source
@@ -831,6 +845,19 @@ DecoupledBPUWithFTB::generateFinalPredAndCreateBubbles()
 
         printFullFTBPrediction(*chosen);
         dbpFtbStats.predsOfEachStage[first_hit_stage]++;
+        if (!squashing && s0PC != MaxAddr && receivedPred && bubblesToCreate > 0) {
+            if (first_hit_stage == 1) {
+                assert(predsOfEachStage[1].valid);
+                if (predsOfEachStage[0].valid) {
+                    dbpFtbStats.overrideByL1WhenL0Hit++;
+                } else {
+                    dbpFtbStats.overrideByL1WhenL0Miss++;
+                }
+                dbpFtbStats.overrideByL1++;
+            }else if (first_hit_stage == 2) {
+                dbpFtbStats.overrideByL2++;
+            }
+        }
     } else {
         bubblesToCreate = 0;
         receivedPred = true;
@@ -2114,6 +2141,7 @@ DecoupledBPUWithFTB::tryEnqFetchStream()
     }
     // prediction valid, but not ready to enq because of bubbles
     if (numOverrideBubbles > 0) {
+        dbpFtbStats.overrideBubbles++;
         DPRINTF(DecoupleBP, "Waiting for bubble caused by overriding, bubbles rest: %u\n", numOverrideBubbles);
         DPRINTF(Override, "Waiting for bubble caused by overriding, bubbles rest: %u\n", numOverrideBubbles);
         return;

src/cpu/pred/ftb/decoupled_bpred.hh

@@ -400,6 +400,13 @@ class DecoupledBPUWithFTB : public BPredUnit
         statistics::Scalar staticBranchNum;
         statistics::Scalar staticBranchNumEverTaken;
 
+        statistics::Scalar overrideByL1;
+        statistics::Scalar overrideByL1WhenL0Hit;
+        statistics::Scalar overrideByL1WhenL0Miss;
+        statistics::Scalar overrideByL2;
+        statistics::Scalar squashWhenOverriding;
+        statistics::Scalar overrideBubbles;
+
         statistics::Vector predsOfEachStage;
         statistics::Vector commitPredsFromEachStage;
         statistics::Distribution fsqEntryDist;

src/cpu/pred/ftb/ftb.cc

@@ -221,16 +221,40 @@ DefaultFTB::lookup(Addr inst_pc)
     Addr ftb_tag = getTag(inst_pc);
     DPRINTF(FTB, "FTB: Looking up FTB entry index %#lx tag %#lx\n", ftb_idx, ftb_tag);
 
+    if (isL0()) {
+        auto tag_it = predTagSet.find(ftb_tag);
+        if (tag_it == predTagSet.end()) {
+            predTagSet.insert(ftb_tag);
+            ftbStats.predTagSetSize++;
+        }
+    }
+
     assert(ftb_idx < numSets);
     // ignore false hit when lowest bit is 1
     const auto &it = ftb[ftb_idx].find(ftb_tag);
     if (it != ftb[ftb_idx].end()) {
+        assert(it->second.valid);
         if (it->second.valid) {
             it->second.tick = curTick();
             std::make_heap(mruList[ftb_idx].begin(), mruList[ftb_idx].end(), older());
             return it->second;
         }
     }
+
+    // ftb not hit
+    bool ftb_is_full = true;
+    for (auto it = ftb[ftb_idx].begin(); it != ftb[ftb_idx].end(); ++it) {
+        if (it->second.tick == 0) {
+            ftb_is_full = false;
+            ftbStats.predMissWhenNotFull++;
+            DPRINTF(FTB, "FTB: Looking up FTB entry index %#lx tag %#lx miss, ftb is not full\n", ftb_idx, ftb_tag);
+            break;
+        }
+    }
+    if (ftb_is_full){
+        ftbStats.predMissWhenFull++;
+        DPRINTF(FTB, "FTB: Looking up FTB entry index %#lx tag %#lx miss, ftb is full\n", ftb_idx, ftb_tag);
+    }
     return TickedFTBEntry();
 }
 
@@ -381,6 +405,14 @@ DefaultFTB::update(const FetchStream &stream)
     Addr ftb_idx = getIndex(startPC);
     Addr ftb_tag = getTag(startPC);
 
+    if (isL0()) {
+        auto tag_it = updateTagSet.find(ftb_tag);
+        if (tag_it == updateTagSet.end()) {
+            updateTagSet.insert(ftb_tag);
+            ftbStats.updateTagSetSize++;
+        }
+    }
+
     DPRINTF(FTB, "FTB: Updating FTB entry index %#lx tag %#lx\n", ftb_idx, ftb_tag);
 
     auto it = ftb[ftb_idx].find(ftb_tag);
@@ -391,6 +423,11 @@ DefaultFTB::update(const FetchStream &stream)
         std::pop_heap(mruList[ftb_idx].begin(), mruList[ftb_idx].end(), older());
         const auto& old_entry = mruList[ftb_idx].back();
         DPRINTF(FTB, "FTB: Replacing entry with tag %#lx in set %#lx\n", old_entry->first, ftb_idx);
+        if (old_entry->second.tick == 0) {
+            ftbStats.updateUseEmptyEntry++;
+        } else {
+            ftbStats.updateUseOldEntry++;
+        }
         ftb[ftb_idx].erase(old_entry->first);
     }
 
@@ -447,6 +484,7 @@ DefaultFTB::update(const FetchStream &stream)
         }
     }
 
+    assert(entry_to_write.valid);
     ftb[ftb_idx][ftb_tag] = TickedFTBEntry(entry_to_write, curTick());
     ftb[ftb_idx][ftb_tag].tag = ftb_tag; // in case different ftb has different tags
 
@@ -580,9 +618,15 @@ DefaultFTB::FTBStats::FTBStats(statistics::Group* parent) :
     ADD_STAT(oldEntryWithNewCond, statistics::units::Count::get(), "number of old ftb entries with new conditional branches"),
     ADD_STAT(oldEntryWithNewUncond, statistics::units::Count::get(), "number of old ftb entries with new unconditional branches"),
     ADD_STAT(predMiss, statistics::units::Count::get(), "misses encountered on prediction"),
+    ADD_STAT(predMissWhenFull, statistics::units::Count::get(), "misses encountered on pred when ftb full"),
+    ADD_STAT(predMissWhenNotFull, statistics::units::Count::get(), "misses encountered on pred when ftb not full"),
     ADD_STAT(predHit, statistics::units::Count::get(), "hits encountered on prediction"),
     ADD_STAT(updateMiss, statistics::units::Count::get(), "misses encountered on update"),
     ADD_STAT(updateHit, statistics::units::Count::get(), "hits encountered on update"),
+    ADD_STAT(updateUseEmptyEntry, statistics::units::Count::get(), "use empty entry when update"),
+    ADD_STAT(updateUseOldEntry, statistics::units::Count::get(), "update old entry when update"),
+    ADD_STAT(predTagSetSize, statistics::units::Count::get(), "uftb pred tag set size"),
+    ADD_STAT(updateTagSetSize, statistics::units::Count::get(), "uftb update tag set size"),
     ADD_STAT(eraseSlotBehindUncond, statistics::units::Count::get(), "erase slots behind unconditional slot"),
     ADD_STAT(predUseL0OnL1Miss, statistics::units::Count::get(), "use l0 result on l1 miss when pred"),
     ADD_STAT(updateUseL0OnL1Miss, statistics::units::Count::get(), "use l0 result on l1 miss when update"),

src/cpu/pred/ftb/ftb.hh

@@ -235,6 +235,10 @@ class DefaultFTB : public TimedBaseFTBPredictor
     /** The number of tag bits per entry. */
     unsigned tagBits;
 
+    /** The number of tags, only used for stats. */
+    std::set<Addr> predTagSet;
+    std::set<Addr> updateTagSet;
+
     /** The tag mask. */
     Addr tagMask;
 
@@ -277,9 +281,16 @@ class DefaultFTB : public TimedBaseFTBPredictor
         statistics::Scalar oldEntryWithNewUncond;
 
         statistics::Scalar predMiss;
+        statistics::Scalar predMissWhenFull;
+        statistics::Scalar predMissWhenNotFull;
         statistics::Scalar predHit;
         statistics::Scalar updateMiss;
         statistics::Scalar updateHit;
+        statistics::Scalar updateUseEmptyEntry;
+        statistics::Scalar updateUseOldEntry;
+
+        statistics::Scalar predTagSetSize;
+        statistics::Scalar updateTagSetSize;
 
         statistics::Scalar eraseSlotBehindUncond;