src/cpu/inorder/resources/fetch_seq_unit.cc

   1 /*
   2  * Copyright (c) 2007 MIPS Technologies, Inc.
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions are
   7  * met: redistributions of source code must retain the above copyright
   8  * notice, this list of conditions and the following disclaimer;
   9  * redistributions in binary form must reproduce the above copyright
  10  * notice, this list of conditions and the following disclaimer in the
  11  * documentation and/or other materials provided with the distribution;
  12  * neither the name of the copyright holders nor the names of its
  13  * contributors may be used to endorse or promote products derived from
  14  * this software without specific prior written permission.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  17  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  18  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  19  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  20  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  21  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  22  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  26  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  *
  28  * Authors: Korey Sewell
  29  *
  30  */
  31
  32 #include "config/the_isa.hh"
  33 #include "cpu/inorder/resources/fetch_seq_unit.hh"
  34 #include "cpu/inorder/resource_pool.hh"
  35 #include "debug/InOrderFetchSeq.hh"
  36 #include "debug/InOrderStall.hh"
  37
  38 using namespace std;
  39 using namespace TheISA;
  40 using namespace ThePipeline;
  41
  42 FetchSeqUnit::FetchSeqUnit(std::string res_name, int res_id, int res_width,
  43                            int res_latency, InOrderCPU *_cpu,
  44                            ThePipeline::Params *params)
  45     : Resource(res_name, res_id, res_width, res_latency, _cpu),
  46       instSize(sizeof(MachInst))
  47 {
  48     for (ThreadID tid = 0; tid < ThePipeline::MaxThreads; tid++) {
  49         pcValid[tid] = false;
  50         pcBlockStage[tid] = 0;
  51
  52         squashSeqNum[tid] = (InstSeqNum)-1;
  53         lastSquashCycle[tid] = 0;
  54     }
  55 }
  56
  57 FetchSeqUnit::~FetchSeqUnit()
  58 {
  59     delete [] resourceEvent;
  60 }
  61
  62 void
  63 FetchSeqUnit::init()
  64 {
  65     resourceEvent = new FetchSeqEvent[width];
  66
  67     for (int i = 0; i < width; i++) {
  68         reqs[i] = new ResourceRequest(this);
  69     }
  70
  71     initSlots();
  72 }
  73
  74 void
  75 FetchSeqUnit::execute(int slot_num)
  76 {
  77     ResourceRequest* fs_req = reqs[slot_num];
  78     DynInstPtr inst = fs_req->inst;
  79     ThreadID tid = inst->readTid();
  80     int stage_num = fs_req->getStageNum();
  81
  82     DPRINTF(InOrderFetchSeq, "[tid:%i]: Current PC is %s\n", tid,
  83             pc[tid]);
  84
  85     switch (fs_req->cmd)
  86     {
  87       case AssignNextPC:
  88         {
  89             if (pcValid[tid]) {
  90                 inst->pcState(pc[tid]);
  91                 inst->setMemAddr(pc[tid].instAddr());
  92
  93                 // Advance to next PC (typically PC + 4)
  94                 pc[tid].advance();
  95
  96                 inst->setSeqNum(cpu->getAndIncrementInstSeq(tid));
  97
  98                 DPRINTF(InOrderFetchSeq, "[tid:%i]: Assigning [sn:%i] to "
  99                         "PC %s\n", tid, inst->seqNum, inst->pcState());
 100
 101                 fs_req->done();
 102             } else {
 103                 DPRINTF(InOrderStall, "STALL: [tid:%i]: NPC not valid\n", tid);
 104                 fs_req->done(false);
 105             }
 106         }
 107         break;
 108
 109       case UpdateTargetPC:
 110         {
 111             assert(!inst->isCondDelaySlot()  &&
 112                    "Not Handling Conditional Delay Slot");
 113
 114             if (inst->isControl()) {
 115                 if (inst->isReturn() && !inst->predTaken()) {
 116                     // If it's a return, then we must wait for resolved address.
 117                     // The Predictor will mark a return a false as "not taken"
 118                     // if there is no RAS entry
 119                     cpu->pipelineStage[stage_num]->
 120                         toPrevStages->stageBlock[stage_num][tid] = true;
 121                     pcValid[tid] = false;
 122                     pcBlockStage[tid] = stage_num;
 123                 } else if (inst->predTaken()) {
 124                     // Taken Control
 125                     inst->setSquashInfo(stage_num);
 126                     setupSquash(inst, stage_num, tid);
 127
 128                     DPRINTF(InOrderFetchSeq, "[tid:%i] Setting up squash to "
 129                             "start from stage %i, after [sn:%i].\n",
 130                             tid, stage_num, inst->bdelaySeqNum);
 131                 }
 132             } else {
 133                 DPRINTF(InOrderFetchSeq, "[tid:%i]: [sn:%i]: Ignoring branch "
 134                         "target update since then is not a control "
 135                         "instruction.\n", tid, inst->seqNum);
 136             }
 137
 138             fs_req->done();
 139         }
 140         break;
 141
 142       default:
 143         fatal("Unrecognized command to %s", resName);
 144     }
 145 }
 146
 147 void
 148 FetchSeqUnit::squash(DynInstPtr inst, int squash_stage,
 149                      InstSeqNum squash_seq_num, ThreadID tid)
 150 {
 151     DPRINTF(InOrderFetchSeq, "[tid:%i]: Updating due to squash from %s (%s) "
 152             "stage %i.\n", tid, inst->instName(), inst->pcState(),
 153             squash_stage);
 154
 155     if (squashSeqNum[tid] <= squash_seq_num &&
 156         lastSquashCycle[tid] == curTick()) {
 157         DPRINTF(InOrderFetchSeq, "[tid:%i]: Ignoring squash from stage %i, "
 158                 "since there is an outstanding squash that is older.\n",
 159                 tid, squash_stage);
 160     } else {
 161         squashSeqNum[tid] = squash_seq_num;
 162         lastSquashCycle[tid] = curTick();
 163
 164         TheISA::PCState nextPC;
 165         assert(inst->staticInst);
 166         if (inst->isControl()) {
 167             nextPC = inst->readPredTarg();
 168
 169             // If we are already fetching this PC then advance to next PC
 170             // =======
 171             // This should handle ISAs w/delay slots and annulled delay
 172             // slots to figure out which is the next PC to fetch after
 173             // a mispredict
 174             DynInstPtr bdelay_inst = NULL;
 175             ListIt bdelay_it;
 176             if (inst->onInstList) {
 177                 bdelay_it = inst->getInstListIt();
 178                 bdelay_it++;
 179             } else {
 180                 InstSeqNum branch_delay_num = inst->seqNum + 1;
 181                 bdelay_it = cpu->findInst(branch_delay_num, tid);
 182             }
 183
 184             if (bdelay_it != cpu->instList[tid].end()) {
 185                 bdelay_inst = (*bdelay_it);
 186             }
 187
 188             if (bdelay_inst) {
 189                 DPRINTF(Resource, "Evaluating %s v. %s\n",
 190                         bdelay_inst->pc, nextPC);
 191
 192                 if (bdelay_inst->pc.instAddr() == nextPC.instAddr()) {
 193                     advancePC(nextPC, inst->staticInst);
 194                     DPRINTF(Resource, "Advanced PC to %s\n", nextPC);
 195                 }
 196             }
 197         } else {
 198             nextPC = inst->pcState();
 199             advancePC(nextPC, inst->staticInst);
 200         }
 201
 202
 203         DPRINTF(InOrderFetchSeq, "[tid:%i]: Setting PC to %s.\n",
 204                 tid, nextPC);
 205         pc[tid] = nextPC;
 206
 207         // Unblock Any Stages Waiting for this information to be updated ...
 208         if (!pcValid[tid]) {
 209             cpu->pipelineStage[pcBlockStage[tid]]->
 210                 toPrevStages->stageUnblock[pcBlockStage[tid]][tid] = true;
 211         }
 212
 213         pcValid[tid] = true;
 214     }
 215
 216     Resource::squash(inst, squash_stage, squash_seq_num, tid);
 217 }
 218
 219 FetchSeqUnit::FetchSeqEvent::FetchSeqEvent()
 220     : ResourceEvent()
 221 { }
 222
 223 void
 224 FetchSeqUnit::FetchSeqEvent::process()
 225 {
 226     FetchSeqUnit* fs_res = dynamic_cast<FetchSeqUnit*>(resource);
 227     assert(fs_res);
 228
 229     for (int i = 0; i < MaxThreads; i++) {
 230         fs_res->pc[i] = fs_res->cpu->pcState(i);
 231         DPRINTF(InOrderFetchSeq, "[tid:%i]: Setting PC: %s.\n",
 232                 fs_res->pc[i]);
 233
 234         fs_res->pcValid[i] = true;
 235     }
 236 }
 237
 238
 239 void
 240 FetchSeqUnit::activateThread(ThreadID tid)
 241 {
 242     pcValid[tid] = true;
 243
 244     pc[tid] = cpu->pcState(tid);
 245
 246     cpu->fetchPriorityList.push_back(tid);
 247
 248     DPRINTF(InOrderFetchSeq, "[tid:%i]: Reading PC: %s.\n",
 249             tid, pc[tid]);
 250 }
 251
 252 void
 253 FetchSeqUnit::deactivateThread(ThreadID tid)
 254 {
 255     pcValid[tid] = false;
 256     pcBlockStage[tid] = 0;
 257
 258     squashSeqNum[tid] = (InstSeqNum)-1;
 259     lastSquashCycle[tid] = 0;
 260
 261     list<ThreadID>::iterator thread_it = find(cpu->fetchPriorityList.begin(),
 262                                               cpu->fetchPriorityList.end(),
 263                                               tid);
 264
 265     if (thread_it != cpu->fetchPriorityList.end())
 266         cpu->fetchPriorityList.erase(thread_it);
 267 }
 268
 269 void
 270 FetchSeqUnit::suspendThread(ThreadID tid)
 271 {
 272     deactivateThread(tid);
 273 }
 274
 275 void
 276 FetchSeqUnit::updateAfterContextSwitch(DynInstPtr inst, ThreadID tid)
 277 {
 278     pcValid[tid] = true;
 279
 280     if (cpu->thread[tid]->lastGradIsBranch) {
 281         /** This function assumes that the instruction causing the context
 282          *  switch was right after the branch. Thus, if it's not, then
 283          *  we are updating incorrectly here
 284          */
 285         assert(cpu->nextInstAddr(tid) == inst->instAddr());
 286         pc[tid] = cpu->thread[tid]->lastBranchPC;
 287     } else {
 288         pc[tid] = inst->pcState();
 289     }
 290     assert(inst->staticInst);
 291     advancePC(pc[tid], inst->staticInst);
 292
 293     DPRINTF(InOrderFetchSeq, "[tid:%i]: Updating PCs due to Context Switch."
 294             "Assigning  PC: %s.\n", tid, pc[tid]);
 295 }