bpu: integrate realistic 2-taken flow in decoupled frontend

Change-Id: Ie2ff36a83d965c4d3f8df51304d7a72c0523cb71

Author: Yakkhini

configs/example/idealkmhv3.py

@@ -80,6 +80,7 @@ def setKmhV3IdealParams(args, system):
         if args.bp_type == 'DecoupledBPUWithBTB':
             cpu.branchPred.ftq_size = 64
             cpu.branchPred.fsq_size = 64
+            cpu.branchPred.enable2Taken = True
             cpu.branchPred.enable2Fetch = True
 
         # l1 cache per core

src/cpu/pred/BranchPredictor.py

@@ -1179,5 +1179,6 @@ class DecoupledBPUWithBTB(BranchPredictor):
     bpDBSwitches = VectorParam.String([], "Enable which traces in the form of database")
     resolveBlockThreshold = Param.Unsigned(8, "Consecutive resolve dequeue failures before blocking prediction once")
 
+    enable2Taken = Param.Bool(True, "Enable realistic 2-taken prediction/training")
     enable2Fetch = Param.Bool(False, "Enable 2fetch feature")
     maxFetchBytesPerCycle = Param.Unsigned(64, "Maximum fetch bytes per cycle for 2fetch")

src/cpu/pred/btb/decoupled_bpred.cc

@@ -48,6 +48,7 @@ DecoupledBPUWithBTB::DecoupledBPUWithBTB(const DecoupledBPUWithBTBParams &p)
       numStages(p.numStages),
       historyManager(16), // TODO: fix this
       resolveBlockThreshold(p.resolveBlockThreshold),
+      enable2Taken(p.enable2Taken),
       enable2Fetch(p.enable2Fetch),
       maxFetchBytesPerCycle(p.maxFetchBytesPerCycle),
       dbpBtbStats(this, p.numStages, p.fsq_size, maxInstsNum)
@@ -131,54 +132,48 @@ DecoupledBPUWithBTB::tick()
         tage->dryRunCycle(s0PC);
         DPRINTF(Override, "Squashing, BPU state updated.\n");
         squashing = false;
+        predDFF.reset();
         return;
     }
 
-    int predsRemainsToBeMade = enableTwoTaken ? 2 : 1;
-    unsigned tempNumOverrideBubbles = 0;
+    if (bpuState == BpuState::IDLE && !targetQueueFull()) {
+        if (blockPredictionPending) {
+            DPRINTF(Override, "Prediction blocked to prioritize resolve update\n");
+            dbpBtbStats.predictionBlockedForUpdate++;
+            blockPredictionPending = false;
+        } else {
+            requestNewPrediction();
+            trainUbtbFor2Taken();
+            predDFF.storePrediction(predsOfEachStage[numStages - 1], ubtbHitIndex);
 
-    while (predsRemainsToBeMade > 0) {
-        // 1. Request new prediction if FSQ not full and we are idle
-        if (bpuState == BpuState::IDLE && !targetQueueFull()) {
-            if (blockPredictionPending) {
-                DPRINTF(Override, "Prediction blocked to prioritize resolve update\n");
-                dbpBtbStats.predictionBlockedForUpdate++;
-                blockPredictionPending = false;
-            } else {
-                requestNewPrediction();
-                bpuState = BpuState::PREDICTOR_DONE;
-            }
-        }
-
-        // 2. Handle pending prediction if available
-        if (bpuState == BpuState::PREDICTOR_DONE) {
             DPRINTF(Override, "Generating final prediction for PC %#lx\n", s0PC);
             numOverrideBubbles = generateFinalPredAndCreateBubbles();
-            bpuState = BpuState::PREDICTION_OUTSTANDING;
+            clearPreds();
+            validateSecondFBPrediction();
 
-            // Clear each predictor's output
-            for (int i = 0; i < numStages; i++) {
-                predsOfEachStage[i].btbEntries.clear();
+            if (hasSecondPrediction) {
+                dbpBtbStats.predProduce2Taken++;
+            } else {
+                dbpBtbStats.predProduce1Taken++;
             }
+            bpuState = BpuState::PREDS_READY;
         }
+    }
 
-        if (bpuState == BpuState::PREDICTION_OUTSTANDING && numOverrideBubbles > 0) {
-            tage->dryRunCycle(s0PC);
-        }
-
-        // check if:
-        // 1. FSQ has space
-        // 2. there's no bubble
-        // 3. PREDICTION_OUTSTANDING
-        if (validateFSQEnqueue()) {
-            // Create new FSQ entry with the current prediction
-            processNewPrediction();
-
-            DPRINTF(Override, "FSQ entry enqueued, prediction state reset\n");
+    if (bpuState == BpuState::PREDS_READY && validateFSQEnqueue()) {
+        processNewPrediction(false);
+        if (hasSecondPrediction) {
+            finalPred = secondPrediction;
+            hasSecondPrediction = false;
+            bpuState = BpuState::WAITING_FOR_SECOND_ENQ;
+        } else {
             bpuState = BpuState::IDLE;
         }
+    }
 
-        predsRemainsToBeMade--;
+    if (bpuState == BpuState::WAITING_FOR_SECOND_ENQ && validateFSQEnqueue()) {
+        processNewPrediction(true);
+        bpuState = BpuState::IDLE;
     }
 
     // Decrement override bubbles counter
@@ -201,19 +196,59 @@ DecoupledBPUWithBTB::tick()
 void
 DecoupledBPUWithBTB::requestNewPrediction()
 {
+    DPRINTF(Override, "Requesting new prediction for PC %#lx\n", s0PC);
 
-        DPRINTF(Override, "Requesting new prediction for PC %#lx\n", s0PC);
+    for (int i = 0; i < numStages; i++) {
+        predsOfEachStage[i].bbStart = s0PC;
+    }
 
-        // Initialize prediction state for each stage
-        for (int i = 0; i < numStages; i++) {
-            predsOfEachStage[i].bbStart = s0PC;
-        }
+    hasSecondPrediction = false;
+    ubtbHitIndex = -1;
+    secondPrediction = FullBTBPrediction();
+    secondPrediction.predSource = 0;
+    secondPrediction.overrideReason = OverrideReason::NO_OVERRIDE;
 
-        // Query each predictor component with current PC and history
-        for (int i = 0; i < numComponents; i++) {
-            components[i]->putPCHistory(s0PC, s0History, predsOfEachStage);  //s0History not used
+    for (int i = 0; i < numComponents; i++) {
+        if (components[i] == ubtb && enable2Taken) {
+            auto [hitIndex, secondAvailable] = ubtb->putPCHistory2Taken(
+                s0PC, s0History, predsOfEachStage, secondPrediction);
+            ubtbHitIndex = hitIndex;
+            hasSecondPrediction = secondAvailable;
+            if (secondAvailable) {
+                dbpBtbStats.twoTakenHit++;
+            } else {
+                dbpBtbStats.twoTakenMiss++;
+            }
+        } else {
+            components[i]->putPCHistory(s0PC, s0History, predsOfEachStage);
         }
+    }
+}
+
+void
+DecoupledBPUWithBTB::trainUbtbFor2Taken()
+{
+    auto &s3_pred = predsOfEachStage[numStages - 1];
+    if (enable2Taken && predDFF.valid) {
+        ubtb->train2Taken(predDFF.prevS3Pred, s3_pred, predDFF.prevUbtbHitIndex);
+    } else {
+        ubtb->train1Taken(s3_pred);
+    }
+    predDFF.reset();
+}
 
+void
+DecoupledBPUWithBTB::validateSecondFBPrediction()
+{
+    if (!hasSecondPrediction) {
+        return;
+    }
+    if (finalPred.predSource != 0) {
+        hasSecondPrediction = false;
+        dbpBtbStats.twoTakenDiscardedByOverride++;
+    } else {
+        dbpBtbStats.twoTakenRemainsAfterOverride++;
+    }
 }
 
 // this function collects predictions from all stages and generate bubbles
@@ -308,9 +343,6 @@ DecoupledBPUWithBTB::generateFinalPredAndCreateBubbles()
 
     // update ubtb/abtb using final S3 prediction
     if (predsOfEachStage[numStages - 1].btbEntries.size() > 0) {
-        if (ubtb->isEnabled()) {
-            ubtb->updateUsingS3Pred(predsOfEachStage[numStages - 1]);
-        }
         if (abtb->isEnabled() && hasTarget(ftqId - 1)) {
             auto previous_block_startpc = getTarget(ftqId - 1).startPC;
             abtb->updateUsingS3Pred(predsOfEachStage[numStages - 1], previous_block_startpc);
@@ -672,7 +704,8 @@ DecoupledBPUWithBTB::validateFSQEnqueue()
     }
 
     // 1. Check if a prediction is available to enqueue
-    if (bpuState != BpuState::PREDICTION_OUTSTANDING) {
+    if (bpuState != BpuState::PREDS_READY &&
+        bpuState != BpuState::WAITING_FOR_SECOND_ENQ) {
         DPRINTF(Override, "No prediction available to enqueue into FSQ\n");
         return false;
     }
@@ -730,7 +763,7 @@ DecoupledBPUWithBTB::pHistShiftIn(int shamt, bool taken, boost::dynamic_bitset<>
  * @return FetchTarget The created fetch target
  */
 FetchTarget
-DecoupledBPUWithBTB::createFetchTargetEntry()
+DecoupledBPUWithBTB::createFetchTargetEntry(bool is_second_pred)
 {
     // Create a new fetch target entry
     FetchTarget entry;
@@ -765,10 +798,16 @@ DecoupledBPUWithBTB::createFetchTargetEntry()
 
     entry.s1Source = finalPred.s1Source;
     entry.s3Source = finalPred.s3Source;
+    entry.isSecondFBPred = is_second_pred;
 
     // Save predictors' metadata
     for (int i = 0; i < numComponents; i++) {
-        entry.predMetas[i] = components[i]->getPredictionMeta();
+        if (is_second_pred) {
+            auto second_meta = components[i]->getSecondPredictionMeta();
+            entry.predMetas[i] = second_meta ? second_meta : components[i]->getPredictionMeta();
+        } else {
+            entry.predMetas[i] = components[i]->getPredictionMeta();
+        }
     }
 
     // Initialize default resolution state
@@ -803,12 +842,12 @@ DecoupledBPUWithBTB::fillAheadPipeline(FetchTarget &entry)
 
 // this function enqueues fsq and update s0PC and s0History
 void
-DecoupledBPUWithBTB::processNewPrediction()
+DecoupledBPUWithBTB::processNewPrediction(bool is_second_pred)
 {
     DPRINTF(DecoupleBP, "Creating new prediction for PC %#lx\n", s0PC);
 
     // 1. Create a new fetch target entry with prediction information
-    FetchTarget entry = createFetchTargetEntry();
+    FetchTarget entry = createFetchTargetEntry(is_second_pred);
 
     // 2. Update global PC state to target or fall-through
     s0PC = finalPred.getTarget(predictWidth);;

src/cpu/pred/btb/decoupled_bpred.hh

@@ -120,9 +120,9 @@ class DecoupledBPUWithBTB : public BPredUnit
 
     enum class BpuState
     {
-        IDLE,               // Waiting to start a prediction.
-        PREDICTOR_DONE,         // Prediction in progress (conceptually replaces `predictorFinished`).
-        PREDICTION_OUTSTANDING,         // Prediction is ready to be enqueued (replaces `receivedPred`).
+        IDLE,
+        PREDS_READY,
+        WAITING_FOR_SECOND_ENQ,
     };
     BpuState bpuState;
 
@@ -143,25 +143,52 @@ class DecoupledBPUWithBTB : public BPredUnit
     unsigned resolveDequeueFailCounter{0};
     const unsigned resolveBlockThreshold;
 
+    const bool enable2Taken;
     const bool enable2Fetch;
     const unsigned maxFetchBytesPerCycle;
 
     unsigned numOverrideBubbles{0};
 
-    bool enableTwoTaken{true};
+    bool hasSecondPrediction{false};
+    FullBTBPrediction secondPrediction;
+    int ubtbHitIndex{-1};
+
+    struct PredictionDFF
+    {
+        bool valid{false};
+        FullBTBPrediction prevS3Pred;
+        int prevUbtbHitIndex{-1};
+
+        void reset()
+        {
+            valid = false;
+            prevUbtbHitIndex = -1;
+            prevS3Pred = FullBTBPrediction();
+        }
+
+        void storePrediction(const FullBTBPrediction &pred, int hitIndex)
+        {
+            prevS3Pred = pred;
+            prevUbtbHitIndex = hitIndex;
+            valid = true;
+        }
+    };
+    PredictionDFF predDFF;
 
     bool validateFSQEnqueue();
 
-    void processNewPrediction();
+    void processNewPrediction(bool is_second_pred = false);
 
-    FetchTarget createFetchTargetEntry();
+    FetchTarget createFetchTargetEntry(bool is_second_pred = false);
 
     void updateHistoryForPrediction(FetchTarget &entry);
 
     void fillAheadPipeline(FetchTarget &entry);
 
     // Tick helper functions
     void requestNewPrediction();
+    void trainUbtbFor2Taken();
+    void validateSecondFBPrediction();
 
     // TODO: compare phr and ghr
     void histShiftIn(int shamt, bool taken, boost::dynamic_bitset<> &history);
@@ -358,6 +385,13 @@ class DecoupledBPUWithBTB : public BPredUnit
         // Window blocking statistics
         statistics::Scalar predictionBlockedForUpdate;  // Times prediction was blocked for update priority
 
+        statistics::Scalar twoTakenHit;
+        statistics::Scalar twoTakenMiss;
+        statistics::Scalar twoTakenDiscardedByOverride;
+        statistics::Scalar twoTakenRemainsAfterOverride;
+        statistics::Scalar predProduce1Taken;
+        statistics::Scalar predProduce2Taken;
+
         statistics::Scalar s1PredWrongFallthrough;
         statistics::Scalar s1PredWrongUbtb;
         statistics::Scalar s1PredWrongAbtb;

src/cpu/pred/btb/decoupled_bpred_stats.cc

@@ -458,6 +458,12 @@ DecoupledBPUWithBTB::DBPBTBStats::DBPBTBStats(
     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(twoTakenHit, statistics::units::Count::get(), "uBTB provided second prediction"),
+    ADD_STAT(twoTakenMiss, statistics::units::Count::get(), "uBTB did not provide second prediction"),
+    ADD_STAT(twoTakenDiscardedByOverride, statistics::units::Count::get(), "second prediction discarded by override"),
+    ADD_STAT(twoTakenRemainsAfterOverride, statistics::units::Count::get(), "second prediction survived override"),
+    ADD_STAT(predProduce1Taken, statistics::units::Count::get(), "cycles producing one prediction"),
+    ADD_STAT(predProduce2Taken, statistics::units::Count::get(), "cycles producing two predictions"),
     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 "),