Yet another merge with the main repository.

[gem5.git] / src / cpu / inorder / resources / graduation_unit.cc

diff --git a/src/cpu/inorder/resources/graduation_unit.cc b/src/cpu/inorder/resources/graduation_unit.cc
index 362641b54e78fb84fedf099ea1502825ad80c3c1..c69e5551293a2f684f45ba78419fd301d60d026c 100644 (file)
--- a/src/cpu/inorder/resources/graduation_unit.cc
+++ b/src/cpu/inorder/resources/graduation_unit.cc
@@ -30,61 +30,95 @@
  */
 
 #include "cpu/inorder/resources/graduation_unit.hh"
+#include "debug/InOrderGraduation.hh"
 
 using namespace ThePipeline;
 
 GraduationUnit::GraduationUnit(std::string res_name, int res_id, int res_width,
                                int res_latency, InOrderCPU *_cpu,
                                ThePipeline::Params *params)
-    : Resource(res_name, res_id, res_width, res_latency, _cpu),
-      lastCycleGrad(0), numCycleGrad(0)
-      
+    : Resource(res_name, res_id, res_width, res_latency, _cpu)
 {
     for (ThreadID tid = 0; tid < ThePipeline::MaxThreads; tid++) {
         nonSpecInstActive[tid] = &cpu->nonSpecInstActive[tid];
         nonSpecSeqNum[tid] = &cpu->nonSpecSeqNum[tid];
+        lastNonSpecTick[tid] = 0;
+        lastFaultTick[tid] = 0;
     }
 }
 
 void
 GraduationUnit::execute(int slot_num)
 {
-    ResourceRequest* grad_req = reqMap[slot_num];
-    DynInstPtr inst = reqMap[slot_num]->inst;
+    ResourceRequest* grad_req = reqs[slot_num];
+    DynInstPtr inst = reqs[slot_num]->inst;
     ThreadID tid = inst->readTid();
     int stage_num = inst->curSkedEntry->stageNum;
+    Tick cur_tick = curTick();
+
+    //@todo: not the common case, anyway we can move this
+    //       check to the stage and just ignore instructions
+    //       after?
+    if (lastNonSpecTick[tid] == cur_tick) {
+        DPRINTF(InOrderGraduation, "Unable to graduate [sn:%i]. "
+                "Only 1 nonspec inst. per cycle can graduate.\n");
+        grad_req->done(false);
+        return;
+    }
+
+    //@todo: use trap Pending
+    if (cpu->trapPending[tid]) {
+        //if (lastFaultTick[tid] == cur_tick) {
+        DPRINTF(InOrderGraduation, "Unable to graduate [sn:%i]. "
+                "Only 1 fault can be handled per tick.\n");
+        grad_req->done(false);
+        return;
+    }
+
 
     switch (grad_req->cmd)
     {
-      case GraduateInst:
+      case CheckFault:
         {
-            // Make sure this is the last thing on the resource schedule
-            // @todo: replace this check
-            // assert(inst->resSched.size() == 1);
-
-             // Handle Any Faults Before Graduating Instruction
+            // Handle Any Faults Before Graduating Instruction
             if (inst->fault != NoFault) {
-                cpu->trap(inst->fault, tid, inst);
-                grad_req->setCompleted(false);
-                 return;
+                DPRINTF(InOrderGraduation, "[tid:%i]: [sn:%i]: fault %s found for %s\n",
+                        tid, inst->seqNum, inst->fault->name(),
+                        inst->instName());
+                squashThenTrap(stage_num, inst);
+                lastFaultTick[tid] = cur_tick;
+                grad_req->done(false);
+                return;
             }
 
+            DPRINTF(InOrderGraduation, "[tid:%i] [sn:%i]: No fault found for %s\n",
+                    tid, inst->seqNum, inst->instName());
+            grad_req->done();
+        }
+        break;
+
+      case GraduateInst:
+        {
             DPRINTF(InOrderGraduation,
-                    "[tid:%i] Graduating instruction [sn:%i].\n",
-                    tid, inst->seqNum);
+                    "[tid:%i]:[sn:%i]: Graduating instruction %s.\n",
+                    tid, inst->seqNum, inst->staticInst->disassemble(inst->instAddr()));
 
             // Release Non-Speculative "Block" on instructions that could not
             // execute because there was a non-speculative inst. active.
             // @TODO: Fix this functionality. Probably too conservative.
+            //        Maybe it should be, non-spec. insts should block other
+            //        non-spec insts because they can potentially be reading
+            //        system state that will be changed by the 1st non-spec inst.
             if (inst->isNonSpeculative()) {
                 *nonSpecInstActive[tid] = false;
                 DPRINTF(InOrderGraduation,
                         "[tid:%i] Non-speculative inst [sn:%i] graduated\n",
                         tid, inst->seqNum);
+                lastNonSpecTick[tid] = cur_tick;
             }
 
             if (inst->traceData) {
-                inst->traceData->setStageCycle(stage_num, curTick());
+                inst->traceData->setStageCycle(stage_num, cur_tick);
             }
 
             // Tell CPU that instruction is finished processing