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 2d7cd5c8c7f28746f4706f4acfe770e2a365adf6..c69e5551293a2f684f45ba78419fd301d60d026c 100644 (file)
--- a/src/cpu/inorder/resources/graduation_unit.cc
+++ b/src/cpu/inorder/resources/graduation_unit.cc
@@ -30,77 +30,100 @@
  */
 
 #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)
-      
+                               int res_latency, InOrderCPU *_cpu,
+                               ThePipeline::Params *params)
+    : 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;
-    Fault fault = reqMap[slot_num]->fault;
+    ResourceRequest* grad_req = reqs[slot_num];
+    DynInstPtr inst = reqs[slot_num]->inst;
     ThreadID tid = inst->readTid();
-    int stage_num = inst->resSched.top()->stageNum;
+    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;
+    }
 
-    grad_req->fault = NoFault;
 
     switch (grad_req->cmd)
     {
-      case GraduateInst:
+      case CheckFault:
         {
-            // @TODO: Instructions should never really get to this point since this should be handled
-            // through the request interface. Check to make sure this happens and delete this
-            // code.
-            if (lastCycleGrad != curTick) {
-                lastCycleGrad = curTick;
-                numCycleGrad = 0;
-            } else if (numCycleGrad > width) {
-                DPRINTF(InOrderGraduation,
-                        "Graduation bandwidth reached for this cycle.\n");
+            // Handle Any Faults Before Graduating Instruction
+            if (inst->fault != NoFault) {
+                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;
             }
 
-            // Make sure this is the last thing on the resource schedule
-            assert(inst->resSched.size() == 1);
+            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);
-
-            DPRINTF(RefCount, "Refcount = %i.\n", 0/*inst->curCount()*/);
+                    "[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.
+            // 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
             cpu->instDone(inst, tid);
 
-            //cpu->pipelineStage[stage_num]->toPrevStages->
-            //stageInfo[stage_num][tid].doneSeqNum = inst->seqNum;
-
             grad_req->done();
         }
         break;