bpu: add realistic 2-taken paths in ubtb

Change-Id: I875ccc0a59f7fff3103bcc4d31740915237fbcc7

Author: Yakkhini

src/cpu/pred/btb/btb_ubtb.cc

@@ -29,6 +29,8 @@
 
 #include "cpu/pred/btb/btb_ubtb.hh"
 
+#include <algorithm>
+
 #include "base/intmath.hh"
 #include "base/trace.hh"
 #include "common.hh"
@@ -117,6 +119,13 @@ UBTB::fillStagePredictions(const TickedUBTBEntry &entry, std::vector<FullBTBPred
     }
 
     if (entry.valid) {
+        for (int i = 0; i < entry.numNTConds; i++) {
+            auto dummy = BTBEntry();
+            dummy.valid = true;
+            dummy.isCond = true;
+            dummy.pc = 0xdeadbeef;
+            FillStageLoop(s) stagePreds[s].btbEntries.push_back(dummy);
+        }
         FillStageLoop(s) stagePreds[s].btbEntries.push_back(BTBEntry(entry));
         if (entry.isCond) {
             // the always taken field of BTBEntry is ignored in uBTB
@@ -133,53 +142,130 @@ UBTB::fillStagePredictions(const TickedUBTBEntry &entry, std::vector<FullBTBPred
     }
 }
 
+void
+UBTB::fillSecondPrediction(const BranchInfo &branchInfo,
+                           Addr bbStart,
+                           FullBTBPrediction &prediction)
+{
+    prediction.btbEntries.clear();
+    prediction.condTakens.clear();
+    prediction.indirectTargets.clear();
+    prediction.bbStart = bbStart;
+    prediction.predTick = curTick();
+    prediction.predSource = 0;
+
+    BTBEntry entry(branchInfo);
+    prediction.btbEntries.push_back(entry);
+    if (entry.isCond && entry.alwaysTaken) {
+        prediction.condTakens.push_back({entry.pc, true});
+    }
+    if (entry.isIndirect) {
+        prediction.indirectTargets.push_back({entry.pc, entry.target});
+        if (entry.isReturn) {
+            prediction.returnTarget = entry.target;
+        }
+    }
+}
+
+void
+UBTB::fillSecondPredictionFallthrough(Addr secondFBStart,
+                                      FullBTBPrediction &prediction)
+{
+    prediction.btbEntries.clear();
+    prediction.condTakens.clear();
+    prediction.indirectTargets.clear();
+    prediction.bbStart = secondFBStart;
+    prediction.predTick = curTick();
+    prediction.predSource = 0;
+}
+
 void
 UBTB::putPCHistory(Addr startAddr, const boost::dynamic_bitset<> &history, std::vector<FullBTBPrediction> &stagePreds)
 {
     meta = std::make_shared<UBTBMeta>();
-    auto it = lookup(startAddr);
+    int hit_index = lookup(startAddr);
     auto& entry = meta->hit_entry;
-    entry = (it != ubtb.end()) ? *it : TickedUBTBEntry();
+    entry = (hit_index >= 0) ? ubtb[hit_index] : TickedUBTBEntry();
 
     PredStatistics(entry, startAddr);
 
     // Fill predictions for each pipeline stage
     fillStagePredictions(entry, stagePreds);
 
     // Update metadata for later stages
-    lastPred.hit_entry = it;
+    lastPred.hit_index = hit_index;
+}
+
+std::pair<int, bool>
+UBTB::putPCHistory2Taken(Addr startAddr,
+                         const boost::dynamic_bitset<> &history,
+                         std::vector<FullBTBPrediction> &stagePreds,
+                         FullBTBPrediction &secondPrediction)
+{
+    meta = std::make_shared<UBTBMeta>();
+    int hit_index = lookup(startAddr);
+    auto &entry = meta->hit_entry;
+    entry = (hit_index >= 0) ? ubtb[hit_index] : TickedUBTBEntry();
+
+    PredStatistics(entry, startAddr);
+    fillStagePredictions(entry, stagePreds);
+    lastPred.hit_index = hit_index;
+
+    bool has_second_prediction = false;
+    secondPrediction.btbEntries.clear();
+    secondPrediction.condTakens.clear();
+    secondPrediction.indirectTargets.clear();
+
+    if (entry.valid && entry.valid_2nd) {
+        Addr second_bb_start = stagePreds[0].getTarget(predictWidth);
+        if (entry.pt_2nd) {
+            fillSecondPrediction(entry.branch_info_2nd, second_bb_start, secondPrediction);
+            if (!secondPrediction.btbEntries.empty()) {
+                Addr control_addr = secondPrediction.getTakenEntry().pc;
+                Addr fall_through = secondPrediction.getFallThrough(predictWidth);
+                if (control_addr >= second_bb_start && control_addr < fall_through) {
+                    has_second_prediction = true;
+                    ubtbStats.twoTakenPredTaken++;
+                } else {
+                    ubtbStats.twoTakenPredRangeFailed++;
+                    secondPrediction.btbEntries.clear();
+                }
+            }
+        } else {
+            fillSecondPredictionFallthrough(second_bb_start, secondPrediction);
+            has_second_prediction = true;
+            ubtbStats.twoTakenPredFallThrough++;
+        }
+    }
+
+    return std::make_pair(hit_index, has_second_prediction);
 }
 
-UBTB::UBTBIter
+int
 UBTB::lookup(Addr startAddr)
 {
     if (startAddr & 0x1) {
-        return ubtb.end();  // ignore false hit when lowest bit is 1
+        return -1;
     }
 
     Addr current_tag = getTag(startAddr);
 
     DPRINTF(UBTB, "UBTB: Doing tag comparison for tag %#lx\n", current_tag);
 
-    auto it = std::find_if(ubtb.begin(), ubtb.end(),
-                           [current_tag](const TickedUBTBEntry &way) { return way.valid && way.tag == current_tag; });
-
-    if (it != ubtb.end()) {
-        // Found a hit - verify no duplicates
-        auto duplicate = std::find_if(std::next(it), ubtb.end(), [current_tag](const TickedUBTBEntry &way) {
-            return way.valid && way.tag == current_tag;
-        });
-        if (duplicate != ubtb.end()) {
-            DPRINTF(UBTB, "UBTB: Multiple hits found in uBTB for the same tag %#lx\n", current_tag);
-            duplicate->valid = false;  // invalidate the duplicate entry
+    for (size_t i = 0; i < ubtb.size(); ++i) {
+        if (!ubtb[i].valid || ubtb[i].tag != current_tag) {
+            continue;
+        }
+        for (size_t j = i + 1; j < ubtb.size(); ++j) {
+            if (ubtb[j].valid && ubtb[j].tag == current_tag) {
+                ubtb[j].valid = false;
+            }
         }
-        // go on to update the mruList
-        it->tick = curTick();  // Update timestamp for MRU
-        // might be unnecessary, considering the heap is updated on every reaplacement
+        ubtb[i].tick = curTick();
         std::make_heap(mruList.begin(), mruList.end(), older());
+        return static_cast<int>(i);
     }
-
-    return it;
+    return -1;
 }
 
 
@@ -204,17 +290,175 @@ UBTB::updateUsingS3Pred(FullBTBPrediction &s3Pred)
         return;
     }
 
+    train1Taken(s3Pred);
+}
+
+int
+UBTB::calculateNumNTConds(FullBTBPrediction& prediction)
+{
+    int numNTConds = prediction.getHistInfo().first;
+    if (prediction.getTakenEntry().isCond) {
+        numNTConds--;
+    }
+    return std::max(0, numNTConds);
+}
+
+bool
+UBTB::shouldSetPtSecond(const FullBTBPrediction& secondPred)
+{
+    return !secondPred.btbEntries.empty();
+}
+
+void
+UBTB::replaceEntry(int entryIndex, FullBTBPrediction &newPrediction)
+{
+    assert(entryIndex >= 0 && entryIndex < static_cast<int>(ubtb.size()));
+    auto taken = newPrediction.getTakenEntry();
+    assert(taken.valid);
+    TickedUBTBEntry newEntry(taken, curTick());
+    newEntry.target = newPrediction.getTarget(predictWidth);
+    newEntry.tag = getTag(newPrediction.bbStart);
+    newEntry.numNTConds = calculateNumNTConds(newPrediction);
+    ubtb[entryIndex] = newEntry;
+}
+
+void
+UBTB::addSecondPredictionToEntry(int entryIndex,
+                                 FullBTBPrediction* secondPred)
+{
+    if (!secondPred) {
+        return;
+    }
+    assert(entryIndex >= 0 && entryIndex < static_cast<int>(ubtb.size()));
+    auto &entry = ubtb[entryIndex];
+    if (!entry.valid) {
+        return;
+    }
+    entry.valid_2nd = true;
+    entry.pt_2nd = shouldSetPtSecond(*secondPred);
+    if (entry.pt_2nd) {
+        auto second_taken = secondPred->getTakenEntry();
+        if (!second_taken.valid) {
+            entry.valid_2nd = false;
+            return;
+        }
+        entry.branch_info_2nd = second_taken;
+        entry.branch_info_2nd.target = secondPred->getTarget(predictWidth);
+    } else {
+        entry.branch_info_2nd = BranchInfo();
+    }
+}
+
+bool
+UBTB::check2TakenConditions(FullBTBPrediction& dff,
+                            const FullBTBPrediction& s3Pred)
+{
+    ubtbStats.twoTakenConditionChecks++;
+    if (dff.btbEntries.empty()) {
+        ubtbStats.twoTakenFailEmptyPreds++;
+        return false;
+    }
+    if (!dff.isTaken()) {
+        ubtbStats.twoTakenFailFirstNotTaken++;
+        return false;
+    }
+    if (s3Pred.btbEntries.empty()) {
+        ubtbStats.twoTakenAcceptFallthrough++;
+        return true;
+    }
+    auto second = s3Pred.btbEntries[0];
+    if (second.isIndirect) {
+        ubtbStats.twoTakenFailSecondIndirect++;
+        return false;
+    }
+    if (second.isCond && !second.alwaysTaken) {
+        ubtbStats.twoTakenFailSecondCond++;
+        return false;
+    }
+    if (second.isCond && second.alwaysTaken) {
+        ubtbStats.twoTakenAcceptAlwaysTaken++;
+        return true;
+    }
+    ubtbStats.twoTakenAcceptOther++;
+    return true;
+}
+
+void
+UBTB::trainCommon(int entry_index,
+                  FullBTBPrediction& pred,
+                  FullBTBPrediction* secondPred)
+{
+    auto s3TakenEntry = pred.getTakenEntry();
+
+    if (entry_index >= 0) {
+        auto &entry = ubtb[entry_index];
+        if (!s3TakenEntry.valid) {
+            updateUCtr(entry.uctr, false);
+            if (entry.uctr == 0) {
+                entry.valid = false;
+                entry.valid_2nd = false;
+            }
+            return;
+        }
+        if (entry.pc != s3TakenEntry.pc ||
+            entry.target != pred.getTarget(predictWidth) ||
+            entry.numNTConds != calculateNumNTConds(pred)) {
+            updateUCtr(entry.uctr, false);
+            if (entry.uctr == 0) {
+                replaceEntry(entry_index, pred);
+                addSecondPredictionToEntry(entry_index, secondPred);
+            }
+        } else {
+            updateUCtr(entry.uctr, true);
+            addSecondPredictionToEntry(entry_index, secondPred);
+        }
+        return;
+    }
+
+    if (!s3TakenEntry.valid) {
+        return;
+    }
+    int toBeReplacedIndex = -1;
+    for (size_t i = 0; i < ubtb.size(); ++i) {
+        if (!ubtb[i].valid) {
+            toBeReplacedIndex = static_cast<int>(i);
+            break;
+        }
+    }
+    if (toBeReplacedIndex == -1) {
+        std::make_heap(mruList.begin(), mruList.end(), older());
+        toBeReplacedIndex = static_cast<int>(mruList.front() - ubtb.begin());
+    }
+    replaceEntry(toBeReplacedIndex, pred);
+    addSecondPredictionToEntry(toBeReplacedIndex, secondPred);
+}
+
+void
+UBTB::train1Taken(FullBTBPrediction &s3Pred)
+{
     auto takenEntry = s3Pred.getTakenEntry();
     if (takenEntry.valid) {
         ubtbStats.s3UpdateHits++;
-    }else {
+    } else {
         ubtbStats.s3UpdateMisses++;
     }
-    auto startAddr = s3Pred.bbStart;
-    UBTBIter oldEntryIter = lastPred.hit_entry;
-    takenEntry.source = getComponentIdx();
-    updateNewEntry(oldEntryIter, takenEntry, startAddr);
+    trainCommon(lastPred.hit_index, s3Pred, nullptr);
+}
 
+void
+UBTB::train2Taken(FullBTBPrediction &dffPred,
+                  FullBTBPrediction &s3Pred,
+                  int hitIndex)
+{
+    if (dffPred.getTarget(predictWidth) != s3Pred.bbStart) {
+        trainCommon(hitIndex, dffPred, nullptr);
+        return;
+    }
+    if (!check2TakenConditions(dffPred, s3Pred)) {
+        trainCommon(hitIndex, dffPred, nullptr);
+        return;
+    }
+    trainCommon(hitIndex, dffPred, &s3Pred);
 }
 
 
@@ -463,7 +707,18 @@ UBTB::UBTBStats::UBTBStats(statistics::Group *parent)
       ADD_STAT(s1Misses3Taken, statistics::units::Count::get(), "s1 misses s3 predicted taken"),
       ADD_STAT(s1Hits3Taken, statistics::units::Count::get(), "s1 hits s3 predicted taken"),
       ADD_STAT(s1Misses3FallThrough, statistics::units::Count::get(), "s1 misses s3 predicted fall through"),
-      ADD_STAT(s1InvalidatedEntries, statistics::units::Count::get(), "s1 invalidated entries")
+      ADD_STAT(s1InvalidatedEntries, statistics::units::Count::get(), "s1 invalidated entries"),
+      ADD_STAT(twoTakenConditionChecks, statistics::units::Count::get(), "2taken condition checks"),
+      ADD_STAT(twoTakenFailEmptyPreds, statistics::units::Count::get(), "2taken reject empty preds"),
+      ADD_STAT(twoTakenFailFirstNotTaken, statistics::units::Count::get(), "2taken reject first not taken"),
+      ADD_STAT(twoTakenFailSecondIndirect, statistics::units::Count::get(), "2taken reject second indirect"),
+      ADD_STAT(twoTakenFailSecondCond, statistics::units::Count::get(), "2taken reject non-always cond second"),
+      ADD_STAT(twoTakenAcceptAlwaysTaken, statistics::units::Count::get(), "2taken accept always-taken cond second"),
+      ADD_STAT(twoTakenAcceptFallthrough, statistics::units::Count::get(), "2taken accept second fallthrough"),
+      ADD_STAT(twoTakenAcceptOther, statistics::units::Count::get(), "2taken accept other second type"),
+      ADD_STAT(twoTakenPredTaken, statistics::units::Count::get(), "2taken predicted second taken"),
+      ADD_STAT(twoTakenPredFallThrough, statistics::units::Count::get(), "2taken predicted second fallthrough"),
+      ADD_STAT(twoTakenPredRangeFailed, statistics::units::Count::get(), "2taken second range check failed")
 {
 }