feat: Implement the new way to train the branch predictor.

Now the rediction and the training is decoupled:
- Redirection can happen speculatively. Redirection requires to restore the branch history (for TAGE) and append the new history of the instruction triggering redirection (e.g., branches, resync request).
- Training the branch predictor happens for all instructions in their commit stage. This step includes updating the BTB as well as update the corresponding counters in the TAGE.

This commit also cleans unused effects related to the branches.

components/BranchPredictor/BTB.cpp

@@ -1,4 +1,5 @@
 #include "BTB.hpp"
+#include "components/uFetch/uFetchTypes.hpp"
 
 #include <cstdint>
 
@@ -92,9 +93,9 @@ BTB::update(VirtualMemoryAddress aPC, eBranchType aType, VirtualMemoryAddress aT
 }
 
 bool
-BTB::update(BranchFeedback const& aFeedback)
+BTB::update(const BPredState &aFeedback)
 {
-    return update(aFeedback.thePC, aFeedback.theActualType, aFeedback.theActualTarget);
+    return update(aFeedback.pc, aFeedback.theActualType, aFeedback.theActualTarget);
 }
 
 json

components/BranchPredictor/BTB.hpp

@@ -2,6 +2,7 @@
 #define FLEXUS_BTB
 
 #include "BTBSet.hpp"
+#include "components/uFetch/uFetchTypes.hpp"
 #include "core/checkpoint/json.hpp"
 #include "core/types.hpp"
 
@@ -36,7 +37,7 @@ class BTB
     boost::optional<VirtualMemoryAddress> target(VirtualMemoryAddress anAddress);
     // Update or add a new entry to the BTB
     bool update(VirtualMemoryAddress aPC, eBranchType aType, VirtualMemoryAddress aTarget);
-    bool update(BranchFeedback const& aFeedback);
+    bool update(const BPredState &aFeedback);
 
     json saveState() const;
     void loadState(json checkpoint);

components/BranchPredictor/BranchPredictor.cpp

@@ -23,10 +23,14 @@ BranchPredictor::BranchPredictor(std::string const& aName, uint32_t anIndex, uin
   , thePredictions_TAGE(aName + "-predictions:TAGE")
   , theCorrect_TAGE(aName + "-correct:TAGE")
   , theMispredict_TAGE(aName + "-mispredict:TAGE")
+  , theMispredict_TAGE_User(aName + "-mispredict:TAGE:User")
+  , theMispredict_TAGE_System(aName + "-mispredict:TAGE:System")
 
   , thePredictions_BTB(aName + "-predictions:BTB")
   , theCorrect_BTB(aName + "-correct:BTB")
   , theMispredict_BTB(aName + "-mispredict:BTB")
+  , theMispredict_BTB_User(aName + "-mispredict:BTB:User")
+  , theMispredict_BTB_System(aName + "-mispredict:BTB:System")
 {
 }
 
@@ -52,11 +56,19 @@ BranchPredictor::predictConditional(VirtualMemoryAddress anAddress, BPredState&
 }
 
 void
-BranchPredictor::reconstructHistory(BPredState aBPState)
+BranchPredictor::recoverHistory(const BPredRedictRequest& aRequest)
 {
-    assert(aBPState.theActualType != kNonBranch);
+    theTage.restore_history(*aRequest.theBPState);
 
-    theTage.restore_all_state(aBPState);
+    if (!aRequest.theInsertNewHistory) {
+        return;
+    }
+
+    const BPredState &aBPState = *aRequest.theBPState;
+
+    if(aBPState.theActualType == Flexus::SharedTypes::kNonBranch) {
+        return;
+    }
 
     if (aBPState.theActualType == kConditional) {
         if (aBPState.theActualDirection == kTaken) {
@@ -77,6 +89,12 @@ BranchPredictor::isBranch(VirtualMemoryAddress anAddress)
     return theBTB.contains(anAddress);
 }
 
+void
+BranchPredictor::checkpointHistory(BPredState& aBPState) const
+{
+    theTage.checkpointHistory(aBPState);
+}
+
 VirtualMemoryAddress
 BranchPredictor::predict(VirtualMemoryAddress anAddress, BPredState& aBPState)
 {
@@ -91,7 +109,6 @@ BranchPredictor::predict(VirtualMemoryAddress anAddress, BPredState& aBPState)
 
     switch (aBPState.thePredictedType) {
         case kNonBranch:
-            theTage.checkpoint_history(aBPState);
             aBPState.thePredictedTarget = VirtualMemoryAddress(0);
             break;
         case kConditional:
@@ -109,7 +126,8 @@ BranchPredictor::predict(VirtualMemoryAddress anAddress, BPredState& aBPState)
             } else {
                 aBPState.thePredictedTarget = VirtualMemoryAddress(0);
             }
-            theTage.get_prediction((uint64_t)anAddress, aBPState);
+            // theTage.get_prediction((uint64_t)anAddress, aBPState);
+            theTage.update_history(aBPState, true, aBPState.pc);
             break;
         default: aBPState.thePredictedTarget = VirtualMemoryAddress(0); break;
     }
@@ -124,55 +142,73 @@ BranchPredictor::predict(VirtualMemoryAddress anAddress, BPredState& aBPState)
 }
 
 void
-BranchPredictor::feedback(VirtualMemoryAddress anAddress,
-                          eBranchType anActualType,
-                          eDirection anActualDirection,
-                          VirtualMemoryAddress anActualAddress,
-                          BPredState& aBPState)
+BranchPredictor::train(const BPredState& aBPState)
 {
+    DBG_(VVerb, (<< "Training Branch Predictor by PC: " << std::hex << aBPState.pc));
     // Implementation of feedback function
-    theBTB.update(anAddress, anActualType, anActualAddress);
+    theBTB.update(aBPState.pc, aBPState.theActualType, aBPState.theActualTarget);
+
+    bool is_system = ((uint64_t)aBPState.pc >> 63) != 0;
 
     bool is_mispredict = false;
-    if (anActualType != aBPState.thePredictedType) {
+    if (aBPState.theActualType != aBPState.thePredictedType) {
         is_mispredict = true;
     } else {
-        if (anActualType == kConditional) {
-            if (!(aBPState.thePrediction >= kNotTaken) && (anActualDirection >= kNotTaken)) {
-                if ((aBPState.thePrediction <= kTaken) && (anActualDirection <= kTaken)) {
-                    if (anActualAddress == aBPState.thePredictedTarget) { is_mispredict = true; }
+        if (aBPState.theActualType == kConditional) {
+            if (!(aBPState.thePrediction >= kNotTaken) && (aBPState.theActualDirection >= kNotTaken)) {
+                if ((aBPState.thePrediction <= kTaken) && (aBPState.theActualDirection <= kTaken)) {
+                    if (aBPState.theActualTarget == aBPState.thePredictedTarget) { is_mispredict = true; }
                 } else {
                     is_mispredict = true;
                 }
             }
         }
     }
 
-    aBPState.theActualDirection = anActualDirection;
-    aBPState.theActualType      = anActualType;
-
     if (is_mispredict) {
-
         if (aBPState.thePredictedType == kConditional) {
             // we need to figure out whether the direction was correct or the target was correct
             if (aBPState.thePrediction <= kTaken) {
-                if (anActualDirection >= kTaken) {
+                if (aBPState.theActualDirection >= kTaken) {
                     ++theMispredict_TAGE;
+                    if (is_system) {
+                        ++theMispredict_TAGE_System;
+                    } else {
+                        ++theMispredict_TAGE_User;
+                    }
                 } else {
                     ++theMispredict_BTB;
+                    if (is_system) {
+                        ++theMispredict_BTB_System;
+                    } else {
+                        ++theMispredict_BTB_User;
+                    }
                 }
             } else {
-                if (anActualAddress != aBPState.thePredictedTarget) {
+                if (aBPState.thePredictedTarget != aBPState.thePredictedTarget) {
                     ++theMispredict_BTB;
+                    if(is_system) {
+                        ++theMispredict_BTB_System;
+                    } else {
+                        ++theMispredict_BTB_User;
+                    }
                 } else {
                     ++theMispredict_TAGE;
+                    if (is_system) {
+                        ++theMispredict_TAGE_System;
+                    } else {
+                        ++theMispredict_TAGE_User;
+                    }
                 }
             }
         } else {
             ++theMispredict_BTB;
+            if (is_system) {
+                ++theMispredict_BTB_System;
+            } else {
+                ++theMispredict_BTB_User;
+            }
         }
-
-        reconstructHistory(aBPState);
     } else {
         // If the prediction was correct, we need to update the stats
         if (aBPState.thePredictedType == kConditional) {
@@ -188,9 +224,9 @@ BranchPredictor::feedback(VirtualMemoryAddress anAddress,
     }
     ++theBranches;
 
-    if (aBPState.thePredictedType == kConditional && anActualType == kConditional) {
-        bool taken = (anActualDirection <= kTaken);
-        theTage.update_predictor(anAddress, aBPState, taken);
+    if (aBPState.thePredictedType == kConditional && aBPState.thePredictedType == kConditional) {
+        bool taken = (aBPState.theActualDirection <= kTaken);
+        theTage.update_predictor(aBPState.pc, aBPState, taken);
     }
 }
 

components/BranchPredictor/BranchPredictor.hpp

@@ -25,10 +25,15 @@ class BranchPredictor
     Stat::StatCounter thePredictions_TAGE;
     Stat::StatCounter theCorrect_TAGE;
     Stat::StatCounter theMispredict_TAGE;
+    Stat::StatCounter theMispredict_TAGE_User;
+    Stat::StatCounter theMispredict_TAGE_System;
 
     Stat::StatCounter thePredictions_BTB;
     Stat::StatCounter theCorrect_BTB;
     Stat::StatCounter theMispredict_BTB;
+    Stat::StatCounter theMispredict_BTB_User;
+    Stat::StatCounter theMispredict_BTB_System;
+
 
   private:
     /* Depending on whether the prediction of the Branch Predictor we use is Taken or Not Taken, the target is returned
@@ -37,18 +42,19 @@ class BranchPredictor
      */
     VirtualMemoryAddress predictConditional(VirtualMemoryAddress anAddress, BPredState& aBPState);
 
-    void reconstructHistory(BPredState aBPState);
-
   public:
     BranchPredictor(std::string const& aName, uint32_t anIndex, uint32_t aBTBSets, uint32_t aBTBWays);
     bool isBranch(VirtualMemoryAddress anAddress);
 
+    void checkpointHistory(BPredState& aBPState) const;
+
     VirtualMemoryAddress predict(VirtualMemoryAddress anAddress, BPredState& aBPState);
-    void feedback(VirtualMemoryAddress anAddress,
-                  eBranchType anActualType,
-                  eDirection anActualDirection,
-                  VirtualMemoryAddress anActualAddress,
-                  BPredState& aBPState);
+
+    // This function is called whenever a prediction is resolved.
+    void recoverHistory(const BPredRedictRequest& aRequest);
+
+    // This function is called whenever an instruction triggering a prediction retires.
+    void train(const BPredState& aBPState);
 
     void loadState(std::string const& aDirName);
     void saveState(std::string const& aDirName);