cpu-o3: fix squash drain and wakeup recovery

Change-Id: Icc05a7320ee5bf1495ef98694c3e92847613d79e

Author: tastynoob

src/cpu/o3/commit.cc

@@ -1263,7 +1263,7 @@ Commit::commitInsts()
                 DPRINTF(Commit, "Retiring squashed instruction from "
                         "ROB.\n");
 
-                rob->retireHead(commit_thread);
+                rob->drainSquashedHead(commit_thread);
 
                 ++stats.commitSquashedInsts;
                 // Notify potential listeners that this instruction is squashed

src/cpu/o3/issue_queue.cc

@@ -382,7 +382,9 @@ IssueQue::checkScoreboard(const DynInstPtr& inst)
         }
         // check bypass data ready or not
         if (!scheduler->bypassScoreboard[src->flatIndex()]) [[unlikely]] {
-            auto dst_inst = scheduler->getInstByDstReg(src->flatIndex());
+            auto dst_inst = scheduler->getInstByDstReg(src->flatIndex(),
+                                                       inst->threadNumber,
+                                                       inst->seqNum);
             assert(dst_inst);
             if (!dst_inst->isLoad()) panic("dst[sn:%llu] is not load, src[sn:%llu]", dst_inst->seqNum, inst->seqNum);
             warn_once(
@@ -1241,18 +1243,28 @@ Scheduler::ready(OpClass op, int disp_seq)
 }
 
 DynInstPtr
-Scheduler::getInstByDstReg(RegIndex flatIdx)
+Scheduler::getInstByDstReg(RegIndex flatIdx, ThreadID tid,
+                           InstSeqNum consumerSeqNum)
 {
+    DynInstPtr candidate = nullptr;
+
     for (auto iq : issueQues) {
-        for (auto& inst : iq->instList) {
-            for (auto i = 0; i < inst->numDestRegs(); i++) {
-                if (inst->renamedDestIdx(i)->flatIndex() == flatIdx) {
-                    return inst;
+        for (auto &inst : iq->instList) {
+            if (inst->threadNumber != tid || inst->seqNum >= consumerSeqNum) {
+                continue;
+            }
+            for (int i = 0; i < inst->numDestRegs(); i++) {
+                if (inst->renamedDestIdx(i)->flatIndex() != flatIdx) {
+                    continue;
+                }
+                if (!candidate || inst->seqNum > candidate->seqNum) {
+                    candidate = inst;
                 }
             }
         }
     }
-    return nullptr;
+
+    return candidate;
 }
 
 void

src/cpu/o3/issue_queue.hh

@@ -370,7 +370,8 @@ class Scheduler : public SimObject
     void issueAndSelect();
     void lookahead(std::deque<DynInstPtr>& insts);
     bool ready(const DynInstPtr& inst, int disp_seq);
-    DynInstPtr getInstByDstReg(RegIndex flatIdx);
+    DynInstPtr getInstByDstReg(RegIndex flatIdx, ThreadID tid,
+                               InstSeqNum consumerSeqNum);
 
     void addProducer(const DynInstPtr& inst);
     // return true if insert successful

src/cpu/o3/rename.cc

@@ -448,9 +448,12 @@ Rename::releasePhysRegs()
         }
 
         removeFromHistory(releaseSeq[tid], tid);
-        // If we committed this cycle then doneSeqNum will be > 0
+        // doneSeqNum is also reused as a squash-progress marker while the
+        // ROB is walking younger entries. Only real commit progress should
+        // release physical registers.
         if (fromCommit->commitInfo[tid].doneSeqNum != 0 &&
-            !fromCommit->commitInfo[tid].squash) {
+            !fromCommit->commitInfo[tid].squash &&
+            !fromCommit->commitInfo[tid].robSquashing) {
 
             finalCommitSeq[tid] = fromCommit->commitInfo[tid].doneSeqNum;
             releaseSeq[tid] =

src/cpu/o3/rob.cc

@@ -428,6 +428,36 @@ ROB::retireHead(ThreadID tid)
     cpu->removeFrontInst(head_inst);
 }
 
+void
+ROB::drainSquashedHead(ThreadID tid)
+{
+    stats.writes++;
+
+    assert(numInstsInROB > 0);
+
+    InstIt head_it = instList[tid].begin();
+
+    DynInstPtr head_inst = std::move(*head_it);
+    instList[tid].erase(head_it);
+
+    assert(head_inst->readyToCommit());
+    assert(head_inst->isSquashed());
+
+    DPRINTF(ROB, "[tid:%i] Draining squashed head instruction, "
+            "instruction PC %s, [sn:%llu]\n", tid, head_inst->pcState(),
+            head_inst->seqNum);
+
+    --numInstsInROB;
+
+    commitGroup(head_inst, tid);
+
+    head_inst->clearInROB();
+
+    updateHead();
+
+    cpu->removeFrontInst(head_inst);
+}
+
 bool
 ROB::isHeadGroupReady(ThreadID tid)
 {

src/cpu/o3/rob.hh

@@ -164,6 +164,11 @@ class ROB
      */
     void retireHead(ThreadID tid);
 
+    /** Drains a squashed head instruction from a specific thread without
+     *  marking it committed.
+     */
+    void drainSquashedHead(ThreadID tid);
+
     /** Is the oldest instruction across all threads ready. */
 //    bool isHeadReady();