gem5  v21.2.1.1
fetch2.cc
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2013-2014,2016 ARM Limited
3  * All rights reserved
4  *
5  * The license below extends only to copyright in the software and shall
6  * not be construed as granting a license to any other intellectual
7  * property including but not limited to intellectual property relating
8  * to a hardware implementation of the functionality of the software
9  * licensed hereunder. You may use the software subject to the license
10  * terms below provided that you ensure that this notice is replicated
11  * unmodified and in its entirety in all distributions of the software,
12  * modified or unmodified, in source code or in binary form.
13  *
14  * Redistribution and use in source and binary forms, with or without
15  * modification, are permitted provided that the following conditions are
16  * met: redistributions of source code must retain the above copyright
17  * notice, this list of conditions and the following disclaimer;
18  * redistributions in binary form must reproduce the above copyright
19  * notice, this list of conditions and the following disclaimer in the
20  * documentation and/or other materials provided with the distribution;
21  * neither the name of the copyright holders nor the names of its
22  * contributors may be used to endorse or promote products derived from
23  * this software without specific prior written permission.
24  *
25  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
26  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
27  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
28  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
29  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
30  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
31  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
32  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
33  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
34  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
35  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
36  */
37 
38 #include "cpu/minor/fetch2.hh"
39 
40 #include <string>
41 
42 #include "arch/generic/decoder.hh"
43 #include "base/logging.hh"
44 #include "base/trace.hh"
45 #include "cpu/minor/pipeline.hh"
46 #include "cpu/null_static_inst.hh"
47 #include "cpu/pred/bpred_unit.hh"
48 #include "debug/Branch.hh"
49 #include "debug/Fetch.hh"
50 #include "debug/MinorTrace.hh"
51 
52 namespace gem5
53 {
54 
56 namespace minor
57 {
58 
59 Fetch2::Fetch2(const std::string &name,
60  MinorCPU &cpu_,
61  const MinorCPUParams &params,
63  Latch<BranchData>::Output branchInp_,
64  Latch<BranchData>::Input predictionOut_,
66  std::vector<InputBuffer<ForwardInstData>> &next_stage_input_buffer) :
67  Named(name),
68  cpu(cpu_),
69  inp(inp_),
70  branchInp(branchInp_),
71  predictionOut(predictionOut_),
72  out(out_),
73  nextStageReserve(next_stage_input_buffer),
74  outputWidth(params.decodeInputWidth),
75  processMoreThanOneInput(params.fetch2CycleInput),
76  branchPredictor(*params.branchPred),
77  fetchInfo(params.numThreads),
78  threadPriority(0), stats(&cpu_)
79 {
80  if (outputWidth < 1)
81  fatal("%s: decodeInputWidth must be >= 1 (%d)\n", name, outputWidth);
82 
83  if (params.fetch2InputBufferSize < 1) {
84  fatal("%s: fetch2InputBufferSize must be >= 1 (%d)\n", name,
85  params.fetch2InputBufferSize);
86  }
87 
88  /* Per-thread input buffers */
89  for (ThreadID tid = 0; tid < params.numThreads; tid++) {
90  inputBuffer.push_back(
92  name + ".inputBuffer" + std::to_string(tid), "lines",
93  params.fetch2InputBufferSize));
94  }
95 }
96 
97 const ForwardLineData *
99 {
100  /* Get a line from the inputBuffer to work with */
101  if (!inputBuffer[tid].empty()) {
102  return &(inputBuffer[tid].front());
103  } else {
104  return NULL;
105  }
106 }
107 
108 void
110 {
111  if (!inputBuffer[tid].empty()) {
112  inputBuffer[tid].front().freeLine();
113  inputBuffer[tid].pop();
114  }
115 
116  fetchInfo[tid].inputIndex = 0;
117 }
118 
119 void
121 {
122  DPRINTF(Fetch, "Dumping whole input buffer\n");
123  while (!inputBuffer[tid].empty())
124  popInput(tid);
125 
126  fetchInfo[tid].inputIndex = 0;
127 }
128 
129 void
131 {
132  MinorDynInstPtr inst = branch.inst;
133 
134  /* Don't even consider instructions we didn't try to predict or faults */
135  if (inst->isFault() || !inst->triedToPredict)
136  return;
137 
138  switch (branch.reason) {
140  /* No data to update */
141  break;
143  /* Never try to predict interrupts */
144  break;
146  /* Don't need to act on suspends */
147  break;
149  /* Don't need to act on fetch wakeup */
150  break;
152  /* Shouldn't happen. Fetch2 is the only source of
153  * BranchPredictions */
154  break;
156  /* Unpredicted branch or barrier */
157  DPRINTF(Branch, "Unpredicted branch seen inst: %s\n", *inst);
158  branchPredictor.squash(inst->id.fetchSeqNum,
159  *branch.target, true, inst->id.threadId);
160  // Update after squashing to accomodate O3CPU
161  // using the branch prediction code.
162  branchPredictor.update(inst->id.fetchSeqNum,
163  inst->id.threadId);
164  break;
166  /* Predicted taken, was taken */
167  DPRINTF(Branch, "Branch predicted correctly inst: %s\n", *inst);
168  branchPredictor.update(inst->id.fetchSeqNum,
169  inst->id.threadId);
170  break;
172  /* Predicted taken, not taken */
173  DPRINTF(Branch, "Branch mis-predicted inst: %s\n", *inst);
174  branchPredictor.squash(inst->id.fetchSeqNum,
175  *branch.target /* Not used */, false, inst->id.threadId);
176  // Update after squashing to accomodate O3CPU
177  // using the branch prediction code.
178  branchPredictor.update(inst->id.fetchSeqNum,
179  inst->id.threadId);
180  break;
182  /* Predicted taken, was taken but to a different target */
183  DPRINTF(Branch, "Branch mis-predicted target inst: %s target: %s\n",
184  *inst, *branch.target);
185  branchPredictor.squash(inst->id.fetchSeqNum,
186  *branch.target, true, inst->id.threadId);
187  break;
188  }
189 }
190 
191 void
193 {
194  Fetch2ThreadInfo &thread = fetchInfo[inst->id.threadId];
195 
196  assert(!inst->predictedTaken);
197 
198  /* Skip non-control/sys call instructions */
199  if (inst->staticInst->isControl() || inst->staticInst->isSyscall()){
200  std::unique_ptr<PCStateBase> inst_pc(inst->pc->clone());
201 
202  /* Tried to predict */
203  inst->triedToPredict = true;
204 
205  DPRINTF(Branch, "Trying to predict for inst: %s\n", *inst);
206 
207  if (branchPredictor.predict(inst->staticInst,
208  inst->id.fetchSeqNum, *inst_pc, inst->id.threadId)) {
209  set(branch.target, *inst_pc);
210  inst->predictedTaken = true;
211  set(inst->predictedTarget, inst_pc);
212  }
213  } else {
214  DPRINTF(Branch, "Not attempting prediction for inst: %s\n", *inst);
215  }
216 
217  /* If we predict taken, set branch and update sequence numbers */
218  if (inst->predictedTaken) {
219  /* Update the predictionSeqNum and remember the streamSeqNum that it
220  * was associated with */
221  thread.expectedStreamSeqNum = inst->id.streamSeqNum;
222 
224  inst->id.threadId,
225  inst->id.streamSeqNum, thread.predictionSeqNum + 1,
226  *inst->predictedTarget, inst);
227 
228  /* Mark with a new prediction number by the stream number of the
229  * instruction causing the prediction */
230  thread.predictionSeqNum++;
231  branch = new_branch;
232 
233  DPRINTF(Branch, "Branch predicted taken inst: %s target: %s"
234  " new predictionSeqNum: %d\n",
235  *inst, *inst->predictedTarget, thread.predictionSeqNum);
236  }
237 }
238 
239 void
241 {
242  /* Push input onto appropriate input buffer */
243  if (!inp.outputWire->isBubble())
244  inputBuffer[inp.outputWire->id.threadId].setTail(*inp.outputWire);
245 
246  ForwardInstData &insts_out = *out.inputWire;
247  BranchData prediction;
248  BranchData &branch_inp = *branchInp.outputWire;
249 
250  assert(insts_out.isBubble());
251 
252  /* React to branches from Execute to update local branch prediction
253  * structures */
254  updateBranchPrediction(branch_inp);
255 
256  /* If a branch arrives, don't try and do anything about it. Only
257  * react to your own predictions */
258  if (branch_inp.isStreamChange()) {
259  DPRINTF(Fetch, "Dumping all input as a stream changing branch"
260  " has arrived\n");
261  dumpAllInput(branch_inp.threadId);
262  fetchInfo[branch_inp.threadId].havePC = false;
263  }
264 
265  assert(insts_out.isBubble());
266  /* Even when blocked, clear out input lines with the wrong
267  * prediction sequence number */
268  for (ThreadID tid = 0; tid < cpu.numThreads; tid++) {
269  Fetch2ThreadInfo &thread = fetchInfo[tid];
270 
271  thread.blocked = !nextStageReserve[tid].canReserve();
272 
273  const ForwardLineData *line_in = getInput(tid);
274 
275  while (line_in &&
276  thread.expectedStreamSeqNum == line_in->id.streamSeqNum &&
277  thread.predictionSeqNum != line_in->id.predictionSeqNum)
278  {
279  DPRINTF(Fetch, "Discarding line %s"
280  " due to predictionSeqNum mismatch (expected: %d)\n",
281  line_in->id, thread.predictionSeqNum);
282 
283  popInput(tid);
284  fetchInfo[tid].havePC = false;
285 
287  DPRINTF(Fetch, "Wrapping\n");
288  line_in = getInput(tid);
289  } else {
290  line_in = NULL;
291  }
292  }
293  }
294 
296  DPRINTF(Fetch, "Scheduled Thread: %d\n", tid);
297 
298  assert(insts_out.isBubble());
299  if (tid != InvalidThreadID) {
300  Fetch2ThreadInfo &fetch_info = fetchInfo[tid];
301 
302  const ForwardLineData *line_in = getInput(tid);
303 
304  unsigned int output_index = 0;
305 
306  /* Pack instructions into the output while we can. This may involve
307  * using more than one input line. Note that lineWidth will be 0
308  * for faulting lines */
309  while (line_in &&
310  (line_in->isFault() ||
311  fetch_info.inputIndex < line_in->lineWidth) && /* More input */
312  output_index < outputWidth && /* More output to fill */
313  prediction.isBubble() /* No predicted branch */)
314  {
315  ThreadContext *thread = cpu.getContext(line_in->id.threadId);
316  InstDecoder *decoder = thread->getDecoderPtr();
317 
318  /* Discard line due to prediction sequence number being wrong but
319  * without the streamSeqNum number having changed */
320  bool discard_line =
321  fetch_info.expectedStreamSeqNum == line_in->id.streamSeqNum &&
322  fetch_info.predictionSeqNum != line_in->id.predictionSeqNum;
323 
324  /* Set the PC if the stream changes. Setting havePC to false in
325  * a previous cycle handles all other change of flow of control
326  * issues */
327  bool set_pc = fetch_info.lastStreamSeqNum != line_in->id.streamSeqNum;
328 
329  if (!discard_line && (!fetch_info.havePC || set_pc)) {
330  /* Set the inputIndex to be the MachInst-aligned offset
331  * from lineBaseAddr of the new PC value */
332  fetch_info.inputIndex =
333  (line_in->pc->instAddr() & decoder->pcMask()) -
334  line_in->lineBaseAddr;
335  DPRINTF(Fetch, "Setting new PC value: %s inputIndex: 0x%x"
336  " lineBaseAddr: 0x%x lineWidth: 0x%x\n",
337  *line_in->pc, fetch_info.inputIndex, line_in->lineBaseAddr,
338  line_in->lineWidth);
339  set(fetch_info.pc, line_in->pc);
340  fetch_info.havePC = true;
341  decoder->reset();
342  }
343 
344  /* The generated instruction. Leave as NULL if no instruction
345  * is to be packed into the output */
346  MinorDynInstPtr dyn_inst = NULL;
347 
348  if (discard_line) {
349  /* Rest of line was from an older prediction in the same
350  * stream */
351  DPRINTF(Fetch, "Discarding line %s (from inputIndex: %d)"
352  " due to predictionSeqNum mismatch (expected: %d)\n",
353  line_in->id, fetch_info.inputIndex,
354  fetch_info.predictionSeqNum);
355  } else if (line_in->isFault()) {
356  /* Pack a fault as a MinorDynInst with ->fault set */
357 
358  /* Make a new instruction and pick up the line, stream,
359  * prediction, thread ids from the incoming line */
360  dyn_inst = new MinorDynInst(nullStaticInstPtr, line_in->id);
361 
362  /* Fetch and prediction sequence numbers originate here */
363  dyn_inst->id.fetchSeqNum = fetch_info.fetchSeqNum;
364  dyn_inst->id.predictionSeqNum = fetch_info.predictionSeqNum;
365  /* To complete the set, test that exec sequence number has
366  * not been set */
367  assert(dyn_inst->id.execSeqNum == 0);
368 
369  set(dyn_inst->pc, fetch_info.pc);
370 
371  /* Pack a faulting instruction but allow other
372  * instructions to be generated. (Fetch2 makes no
373  * immediate judgement about streamSeqNum) */
374  dyn_inst->fault = line_in->fault;
375  DPRINTF(Fetch, "Fault being passed output_index: "
376  "%d: %s\n", output_index, dyn_inst->fault->name());
377  } else {
378  uint8_t *line = line_in->line;
379 
380  /* The instruction is wholly in the line, can just copy. */
381  memcpy(decoder->moreBytesPtr(), line + fetch_info.inputIndex,
382  decoder->moreBytesSize());
383 
384  if (!decoder->instReady()) {
385  decoder->moreBytes(*fetch_info.pc,
386  line_in->lineBaseAddr + fetch_info.inputIndex);
387  DPRINTF(Fetch, "Offering MachInst to decoder addr: 0x%x\n",
388  line_in->lineBaseAddr + fetch_info.inputIndex);
389  }
390 
391  /* Maybe make the above a loop to accomodate ISAs with
392  * instructions longer than sizeof(MachInst) */
393 
394  if (decoder->instReady()) {
395  /* Note that the decoder can update the given PC.
396  * Remember not to assign it until *after* calling
397  * decode */
398  StaticInstPtr decoded_inst =
399  decoder->decode(*fetch_info.pc);
400 
401  /* Make a new instruction and pick up the line, stream,
402  * prediction, thread ids from the incoming line */
403  dyn_inst = new MinorDynInst(decoded_inst, line_in->id);
404 
405  /* Fetch and prediction sequence numbers originate here */
406  dyn_inst->id.fetchSeqNum = fetch_info.fetchSeqNum;
407  dyn_inst->id.predictionSeqNum = fetch_info.predictionSeqNum;
408  /* To complete the set, test that exec sequence number
409  * has not been set */
410  assert(dyn_inst->id.execSeqNum == 0);
411 
412  set(dyn_inst->pc, fetch_info.pc);
413  DPRINTF(Fetch, "decoder inst %s\n", *dyn_inst);
414 
415  // Collect some basic inst class stats
416  if (decoded_inst->isLoad())
418  else if (decoded_inst->isStore())
420  else if (decoded_inst->isAtomic())
422  else if (decoded_inst->isVector())
424  else if (decoded_inst->isFloating())
426  else if (decoded_inst->isInteger())
428 
429  DPRINTF(Fetch, "Instruction extracted from line %s"
430  " lineWidth: %d output_index: %d inputIndex: %d"
431  " pc: %s inst: %s\n",
432  line_in->id,
433  line_in->lineWidth, output_index, fetch_info.inputIndex,
434  *fetch_info.pc, *dyn_inst);
435 
436  /*
437  * In SE mode, it's possible to branch to a microop when
438  * replaying faults such as page faults (or simply
439  * intra-microcode branches in X86). Unfortunately,
440  * as Minor has micro-op decomposition in a separate
441  * pipeline stage from instruction decomposition, the
442  * following advancePC (which may follow a branch with
443  * microPC() != 0) *must* see a fresh macroop.
444  *
445  * X86 can branch within microops so we need to deal with
446  * the case that, after a branch, the first un-advanced PC
447  * may be pointing to a microop other than 0. Once
448  * advanced, however, the microop number *must* be 0
449  */
450  fetch_info.pc->uReset();
451 
452  /* Advance PC for the next instruction */
453  decoded_inst->advancePC(*fetch_info.pc);
454 
455  /* Predict any branches and issue a branch if
456  * necessary */
457  predictBranch(dyn_inst, prediction);
458  } else {
459  DPRINTF(Fetch, "Inst not ready yet\n");
460  }
461 
462  /* Step on the pointer into the line if there's no
463  * complete instruction waiting */
464  if (decoder->needMoreBytes()) {
465  fetch_info.inputIndex += decoder->moreBytesSize();
466 
467  DPRINTF(Fetch, "Updated inputIndex value PC: %s"
468  " inputIndex: 0x%x lineBaseAddr: 0x%x lineWidth: 0x%x\n",
469  *line_in->pc, fetch_info.inputIndex, line_in->lineBaseAddr,
470  line_in->lineWidth);
471  }
472  }
473 
474  if (dyn_inst) {
475  /* Step to next sequence number */
476  fetch_info.fetchSeqNum++;
477 
478  /* Correctly size the output before writing */
479  if (output_index == 0) {
480  insts_out.resize(outputWidth);
481  }
482  /* Pack the generated dynamic instruction into the output */
483  insts_out.insts[output_index] = dyn_inst;
484  output_index++;
485 
486  /* Output MinorTrace instruction info for
487  * pre-microop decomposition macroops */
488  if (debug::MinorTrace && !dyn_inst->isFault() &&
489  dyn_inst->staticInst->isMacroop())
490  {
491  dyn_inst->minorTraceInst(*this,
492  cpu.threads[0]->getIsaPtr()->regClasses());
493  }
494  }
495 
496  /* Remember the streamSeqNum of this line so we can tell when
497  * we change stream */
498  fetch_info.lastStreamSeqNum = line_in->id.streamSeqNum;
499 
500  /* Asked to discard line or there was a branch or fault */
501  if (!prediction.isBubble() || /* The remains of a
502  line with a prediction in it */
503  line_in->isFault() /* A line which is just a fault */)
504  {
505  DPRINTF(Fetch, "Discarding all input on branch/fault\n");
506  dumpAllInput(tid);
507  fetch_info.havePC = false;
508  line_in = NULL;
509  } else if (discard_line) {
510  /* Just discard one line, one's behind it may have new
511  * stream sequence numbers. There's a DPRINTF above
512  * for this event */
513  popInput(tid);
514  fetch_info.havePC = false;
515  line_in = NULL;
516  } else if (fetch_info.inputIndex == line_in->lineWidth) {
517  /* Got to end of a line, pop the line but keep PC
518  * in case this is a line-wrapping inst. */
519  popInput(tid);
520  line_in = NULL;
521  }
522 
523  if (!line_in && processMoreThanOneInput) {
524  DPRINTF(Fetch, "Wrapping\n");
525  line_in = getInput(tid);
526  }
527  }
528 
529  /* The rest of the output (if any) should already have been packed
530  * with bubble instructions by insts_out's initialisation */
531  }
532  if (tid == InvalidThreadID) {
533  assert(insts_out.isBubble());
534  }
536  *predictionOut.inputWire = prediction;
537 
538  /* If we generated output, reserve space for the result in the next stage
539  * and mark the stage as being active this cycle */
540  if (!insts_out.isBubble()) {
541  /* Note activity of following buffer */
543  insts_out.threadId = tid;
544  nextStageReserve[tid].reserve();
545  }
546 
547  /* If we still have input to process and somewhere to put it,
548  * mark stage as active */
549  for (ThreadID i = 0; i < cpu.numThreads; i++)
550  {
551  if (getInput(i) && nextStageReserve[i].canReserve()) {
553  break;
554  }
555  }
556 
557  /* Make sure the input (if any left) is pushed */
558  if (!inp.outputWire->isBubble())
559  inputBuffer[inp.outputWire->id.threadId].pushTail();
560 }
561 
562 inline ThreadID
564 {
565  /* Select thread via policy. */
566  std::vector<ThreadID> priority_list;
567 
568  switch (cpu.threadPolicy) {
569  case enums::SingleThreaded:
570  priority_list.push_back(0);
571  break;
572  case enums::RoundRobin:
573  priority_list = cpu.roundRobinPriority(threadPriority);
574  break;
575  case enums::Random:
576  priority_list = cpu.randomPriority();
577  break;
578  default:
579  panic("Unknown fetch policy");
580  }
581 
582  for (auto tid : priority_list) {
583  if (getInput(tid) && !fetchInfo[tid].blocked) {
584  threadPriority = tid;
585  return tid;
586  }
587  }
588 
589  return InvalidThreadID;
590 }
591 
592 bool
594 {
595  for (const auto &buffer : inputBuffer) {
596  if (!buffer.empty())
597  return false;
598  }
599 
600  return (*inp.outputWire).isBubble() &&
601  (*predictionOut.inputWire).isBubble();
602 }
603 
605  : statistics::Group(cpu, "fetch2"),
606  ADD_STAT(intInstructions, statistics::units::Count::get(),
607  "Number of integer instructions successfully decoded"),
608  ADD_STAT(fpInstructions, statistics::units::Count::get(),
609  "Number of floating point instructions successfully decoded"),
610  ADD_STAT(vecInstructions, statistics::units::Count::get(),
611  "Number of SIMD instructions successfully decoded"),
612  ADD_STAT(loadInstructions, statistics::units::Count::get(),
613  "Number of memory load instructions successfully decoded"),
614  ADD_STAT(storeInstructions, statistics::units::Count::get(),
615  "Number of memory store instructions successfully decoded"),
616  ADD_STAT(amoInstructions, statistics::units::Count::get(),
617  "Number of memory atomic instructions successfully decoded")
618 {
631 }
632 
633 void
635 {
636  std::ostringstream data;
637 
638  if (fetchInfo[0].blocked)
639  data << 'B';
640  else
641  (*out.inputWire).reportData(data);
642 
643  minor::minorTrace("inputIndex=%d havePC=%d predictionSeqNum=%d insts=%s\n",
644  fetchInfo[0].inputIndex, fetchInfo[0].havePC,
645  fetchInfo[0].predictionSeqNum, data.str());
646  inputBuffer[0].minorTrace();
647 }
648 
649 } // namespace minor
650 } // namespace gem5
gem5::minor::ForwardLineData
Line fetch data in the forward direction.
Definition: pipe_data.hh:187
fatal
#define fatal(...)
This implements a cprintf based fatal() function.
Definition: logging.hh:190
gem5::branch_prediction::BPredUnit::update
void update(const InstSeqNum &done_sn, ThreadID tid)
Tells the branch predictor to commit any updates until the given sequence number.
Definition: bpred_unit.cc:304
gem5::MinorCPU::randomPriority
std::vector< ThreadID > randomPriority()
Definition: cpu.hh:182
gem5::branch_prediction::BPredUnit::predict
bool predict(const StaticInstPtr &inst, const InstSeqNum &seqNum, PCStateBase &pc, ThreadID tid)
Predicts whether or not the instruction is a taken branch, and the target of the branch if it is take...
Definition: bpred_unit.cc:131
gem5::minor::BranchData::target
std::unique_ptr< PCStateBase > target
Starting PC of that stream.
Definition: pipe_data.hh:123
gem5::minor::ForwardLineData::id
InstId id
Thread, stream, prediction ...
Definition: pipe_data.hh:215
gem5::minor::ForwardInstData::isBubble
bool isBubble() const
BubbleIF interface.
Definition: pipe_data.cc:251
data
const char data[]
Definition: circlebuf.test.cc:48
gem5::minor::ForwardInstData::insts
MinorDynInstPtr insts[MAX_FORWARD_INSTS]
Array of carried insts, ref counted.
Definition: pipe_data.hh:288
gem5::minor::Fetch2::Fetch2ThreadInfo::pc
std::unique_ptr< PCStateBase > pc
Remembered program counter value.
Definition: fetch2.hh:131
gem5::minor::ForwardInstData::threadId
ThreadID threadId
Thread associated with these instructions.
Definition: pipe_data.hh:294
gem5::auxv::Random
@ Random
Definition: aux_vector.hh:87
gem5::minor::Fetch2::Fetch2ThreadInfo::lastStreamSeqNum
InstSeqNum lastStreamSeqNum
Stream sequence number of the last seen line used to identify changes of instruction stream.
Definition: fetch2.hh:140
gem5::minor::BranchData::reason
Reason reason
Explanation for this branch.
Definition: pipe_data.hh:113
gem5::minor::Fetch2::Fetch2ThreadInfo
Data members after this line are cycle-to-cycle state.
Definition: fetch2.hh:105
sc_dt::to_string
const std::string to_string(sc_enc enc)
Definition: sc_fxdefs.cc:91
gem5::minor::Fetch2::processMoreThanOneInput
bool processMoreThanOneInput
If true, more than one input word can be processed each cycle if there is room in the output to conta...
Definition: fetch2.hh:93
minor
gem5::MinorCPU
MinorCPU is an in-order CPU model with four fixed pipeline stages:
Definition: cpu.hh:85
gem5::minor::ForwardLineData::lineWidth
unsigned int lineWidth
Explicit line width, don't rely on data.size.
Definition: pipe_data.hh:207
gem5::minor::Fetch2::minorTrace
void minorTrace() const
Definition: fetch2.cc:634
std::vector
STL vector class.
Definition: stl.hh:37
gem5::minor::BranchData::NoBranch
@ NoBranch
Definition: pipe_data.hh:74
gem5::minor::Fetch2::Fetch2Stats::loadInstructions
statistics::Scalar loadInstructions
Definition: fetch2.hh:171
gem5::minor::ForwardInstData
Forward flowing data between Fetch2,Decode,Execute carrying a packet of instructions of a width appro...
Definition: pipe_data.hh:284
gem5::minor::Fetch2::updateBranchPrediction
void updateBranchPrediction(const BranchData &branch)
Update local branch prediction structures from feedback from Execute.
Definition: fetch2.cc:130
gem5::ArmISA::i
Bitfield< 7 > i
Definition: misc_types.hh:67
gem5::StaticInst::advancePC
virtual void advancePC(PCStateBase &pc_state) const =0
gem5::minor::Fetch2::Fetch2ThreadInfo::inputIndex
unsigned int inputIndex
Index into an incompletely processed input line that instructions are to be extracted from.
Definition: fetch2.hh:122
gem5::minor::BranchData::isStreamChange
static bool isStreamChange(const BranchData::Reason reason)
Is a request with this reason actually a request to change the PC rather than a bubble or branch pred...
Definition: pipe_data.cc:85
gem5::minor::Fetch2::branchPredictor
branch_prediction::BPredUnit & branchPredictor
Branch predictor passed from Python configuration.
Definition: fetch2.hh:96
gem5::RefCountingPtr< MinorDynInst >
gem5::MinorCPU::threads
std::vector< minor::MinorThread * > threads
These are thread state-representing objects for this CPU.
Definition: cpu.hh:101
gem5::minor::Fetch2::inp
Latch< ForwardLineData >::Output inp
Input port carrying lines from Fetch1.
Definition: fetch2.hh:73
gem5::minor::InputBuffer
Like a Queue but with a restricted interface and a setTail function which, when the queue is empty,...
Definition: buffers.hh:572
gem5::minor::Fetch2::predictionOut
Latch< BranchData >::Input predictionOut
Output port carrying predictions back to Fetch1.
Definition: fetch2.hh:80
gem5::Named
Interface for things with names.
Definition: named.hh:38
fetch2.hh
gem5::StaticInst::isFloating
bool isFloating() const
Definition: static_inst.hh:178
gem5::minor::Latch::Output
Definition: buffers.hh:263
gem5::minor::Fetch2::getInput
const ForwardLineData * getInput(ThreadID tid)
Get a piece of data to work on from the inputBuffer, or 0 if there is no data.
Definition: fetch2.cc:98
gem5::nullStaticInstPtr
const StaticInstPtr nullStaticInstPtr
Statically allocated null StaticInstPtr.
Definition: null_static_inst.cc:36
gem5::minor::BranchData::Interrupt
@ Interrupt
Definition: pipe_data.hh:97
gem5::minor::Fetch2::Fetch2Stats::vecInstructions
statistics::Scalar vecInstructions
Definition: fetch2.hh:170
decoder.hh
gem5::ThreadContext
ThreadContext is the external interface to all thread state for anything outside of the CPU.
Definition: thread_context.hh:94
gem5::minor::Fetch2::branchInp
Latch< BranchData >::Output branchInp
Input port carrying branches from Execute.
Definition: fetch2.hh:77
gem5::Named::name
virtual std::string name() const
Definition: named.hh:47
gem5::minor::ForwardLineData::pc
std::unique_ptr< PCStateBase > pc
PC of the first inst within this sequence.
Definition: pipe_data.hh:201
gem5::StaticInst::isAtomic
bool isAtomic() const
Definition: static_inst.hh:170
gem5::InstDecoder
Definition: decoder.hh:42
DPRINTF
#define DPRINTF(x,...)
Definition: trace.hh:186
ADD_STAT
#define ADD_STAT(n,...)
Convenience macro to add a stat to a statistics group.
Definition: group.hh:75
gem5::minor::BranchData::CorrectlyPredictedBranch
@ CorrectlyPredictedBranch
Definition: pipe_data.hh:77
gem5::minor::Latch::Input
Encapsulate wires on either input or output of the latch.
Definition: buffers.hh:252
gem5::ThreadContext::getDecoderPtr
virtual InstDecoder * getDecoderPtr()=0
gem5::minor::InstId::streamSeqNum
InstSeqNum streamSeqNum
The 'stream' this instruction belongs to.
Definition: dyn_inst.hh:94
gem5::minor::Fetch2::Fetch2ThreadInfo::predictionSeqNum
InstSeqNum predictionSeqNum
Fetch2 is the source of prediction sequence numbers.
Definition: fetch2.hh:155
gem5::minor::BranchData::BadlyPredictedBranchTarget
@ BadlyPredictedBranchTarget
Definition: pipe_data.hh:86
pipeline.hh
gem5::minor::Fetch2::fetchInfo
std::vector< Fetch2ThreadInfo > fetchInfo
Definition: fetch2.hh:161
gem5::StaticInst::isLoad
bool isLoad() const
Definition: static_inst.hh:168
gem5::minor::ForwardLineData::line
uint8_t * line
Line data.
Definition: pipe_data.hh:219
gem5::StaticInst::isStore
bool isStore() const
Definition: static_inst.hh:169
gem5::InvalidThreadID
const ThreadID InvalidThreadID
Definition: types.hh:243
gem5::StaticInst::isVector
bool isVector() const
Definition: static_inst.hh:179
gem5::minor::BranchData
Forward data betwen Execute and Fetch1 carrying change-of-address/stream information.
Definition: pipe_data.hh:66
gem5::minor::Fetch2::Fetch2Stats::intInstructions
statistics::Scalar intInstructions
Stats.
Definition: fetch2.hh:168
gem5::minor::Fetch2::dumpAllInput
void dumpAllInput(ThreadID tid)
Dump the whole contents of the input buffer.
Definition: fetch2.cc:120
gem5::branch_prediction::BPredUnit::squash
void squash(const InstSeqNum &squashed_sn, ThreadID tid)
Squashes all outstanding updates until a given sequence number.
Definition: bpred_unit.cc:327
gem5::minor::Pipeline::Fetch2StageId
@ Fetch2StageId
Definition: pipeline.hh:104
null_static_inst.hh
gem5::minor::Fetch2::threadPriority
ThreadID threadPriority
Definition: fetch2.hh:162
gem5::minor::BranchData::inst
MinorDynInstPtr inst
Instruction which caused this branch.
Definition: pipe_data.hh:126
gem5::GEM5_DEPRECATED_NAMESPACE
GEM5_DEPRECATED_NAMESPACE(GuestABI, guest_abi)
gem5::minor::BranchData::isBubble
bool isBubble() const
Definition: pipe_data.hh:164
gem5::minor::Fetch2::evaluate
void evaluate()
Pass on input/buffer data to the output if you can.
Definition: fetch2.cc:240
name
const std::string & name()
Definition: trace.cc:49
gem5::minor::minorTrace
void minorTrace(const char *fmt, Args ...args)
DPRINTFN for MinorTrace reporting.
Definition: trace.hh:67
gem5::minor::Fetch2::isDrained
bool isDrained()
Is this stage drained? For Fetch2, draining is initiated by Execute halting Fetch1 causing Fetch2 to ...
Definition: fetch2.cc:593
gem5::minor::ForwardLineData::isFault
bool isFault() const
This is a fault, not a line.
Definition: pipe_data.hh:251
gem5::minor::Fetch2::inputBuffer
std::vector< InputBuffer< ForwardLineData > > inputBuffer
Definition: fetch2.hh:100
gem5::ActivityRecorder::activity
void activity()
Records that there is activity this cycle.
Definition: activity.cc:55
gem5::minor::Fetch2::popInput
void popInput(ThreadID tid)
Pop an element off the input buffer, if there are any.
Definition: fetch2.cc:109
gem5::minor::Fetch2::cpu
MinorCPU & cpu
Pointer back to the containing CPU.
Definition: fetch2.hh:70
gem5::minor::Fetch2::Fetch2Stats::amoInstructions
statistics::Scalar amoInstructions
Definition: fetch2.hh:173
gem5::ActivityRecorder::activateStage
void activateStage(const int idx)
Marks a stage as active.
Definition: activity.cc:91
gem5::minor::ForwardInstData::resize
void resize(unsigned int width)
Resize a bubble/empty ForwardInstData and fill with bubbles.
Definition: pipe_data.cc:264
gem5::minor::Fetch2::Fetch2Stats::Fetch2Stats
Fetch2Stats(MinorCPU *cpu)
Definition: fetch2.cc:604
gem5::minor::MinorDynInst
Dynamic instruction for Minor.
Definition: dyn_inst.hh:163
gem5::minor::BranchData::threadId
ThreadID threadId
ThreadID associated with branch.
Definition: pipe_data.hh:116
bpred_unit.hh
gem5::SparcISA::Branch
Base class for branch operations.
Definition: branch.hh:48
gem5::minor::Fetch2::out
Latch< ForwardInstData >::Input out
Output port carrying instructions into Decode.
Definition: fetch2.hh:83
gem5::minor::BranchData::HaltFetch
@ HaltFetch
Definition: pipe_data.hh:99
gem5::minor::Fetch2::Fetch2
Fetch2(const std::string &name, MinorCPU &cpu_, const MinorCPUParams &params, Latch< ForwardLineData >::Output inp_, Latch< BranchData >::Output branchInp_, Latch< BranchData >::Input predictionOut_, Latch< ForwardInstData >::Input out_, std::vector< InputBuffer< ForwardInstData >> &next_stage_input_buffer)
Definition: fetch2.cc:59
gem5::minor::Fetch2::Fetch2ThreadInfo::havePC
bool havePC
PC is currently valid.
Definition: fetch2.hh:136
gem5::minor::BranchData::BranchPrediction
@ BranchPrediction
Definition: pipe_data.hh:84
logging.hh
gem5::statistics::Group
Statistics container.
Definition: group.hh:93
gem5::StaticInst::isInteger
bool isInteger() const
Definition: static_inst.hh:177
gem5::minor::ForwardLineData::lineBaseAddr
Addr lineBaseAddr
First byte address in the line.
Definition: pipe_data.hh:198
gem5::minor::BranchData::BadlyPredictedBranch
@ BadlyPredictedBranch
Definition: pipe_data.hh:90
gem5::minor::ForwardLineData::fault
Fault fault
This line has a fault.
Definition: pipe_data.hh:212
gem5::minor::Fetch2::Fetch2ThreadInfo::expectedStreamSeqNum
InstSeqNum expectedStreamSeqNum
Stream sequence number remembered from last time the predictionSeqNum changed.
Definition: fetch2.hh:150
gem5::MinorCPU::threadPolicy
enums::ThreadPolicy threadPolicy
Thread Scheduling Policy (RoundRobin, Random, etc)
Definition: cpu.hh:120
trace.hh
gem5::MinorCPU::activityRecorder
minor::MinorActivityRecorder * activityRecorder
Activity recording for pipeline.
Definition: cpu.hh:96
decoder
output decoder
Definition: nop.cc:61
gem5::statistics::DataWrap::flags
Derived & flags(Flags _flags)
Set the flags and marks this stat to print at the end of simulation.
Definition: statistics.hh:358
gem5::minor::Fetch2::stats
gem5::minor::Fetch2::Fetch2Stats stats
gem5::minor::Fetch2::Fetch2ThreadInfo::fetchSeqNum
InstSeqNum fetchSeqNum
Fetch2 is the source of fetch sequence numbers.
Definition: fetch2.hh:144
gem5::minor::BranchData::SuspendThread
@ SuspendThread
Definition: pipe_data.hh:95
gem5::minor::Fetch2::Fetch2Stats::fpInstructions
statistics::Scalar fpInstructions
Definition: fetch2.hh:169
gem5
Reference material can be found at the JEDEC website: UFS standard http://www.jedec....
Definition: tlb.cc:60
gem5::statistics::total
const FlagsType total
Print the total.
Definition: info.hh:60
gem5::minor::InstId::predictionSeqNum
InstSeqNum predictionSeqNum
The predicted qualifier to stream, attached by Fetch2 as a consequence of branch prediction.
Definition: dyn_inst.hh:98
gem5::minor::Fetch2::Fetch2Stats::storeInstructions
statistics::Scalar storeInstructions
Definition: fetch2.hh:172
gem5::minor::BranchData::UnpredictedBranch
@ UnpredictedBranch
Definition: pipe_data.hh:82
gem5::minor::Fetch2::nextStageReserve
std::vector< InputBuffer< ForwardInstData > > & nextStageReserve
Interface to reserve space in the next stage.
Definition: fetch2.hh:86
gem5::MinorCPU::roundRobinPriority
std::vector< ThreadID > roundRobinPriority(ThreadID priority)
Thread scheduling utility functions.
Definition: cpu.hh:173
gem5::minor::Fetch2::getScheduledThread
ThreadID getScheduledThread()
Use the current threading policy to determine the next thread to fetch from.
Definition: fetch2.cc:563
gem5::minor::Fetch2::Fetch2ThreadInfo::blocked
bool blocked
Blocked indication for report.
Definition: fetch2.hh:158
gem5::ThreadID
int16_t ThreadID
Thread index/ID type.
Definition: types.hh:242
gem5::minor::Fetch2::outputWidth
unsigned int outputWidth
Width of output of this stage/input of next in instructions.
Definition: fetch2.hh:89
gem5::minor::InstId::threadId
ThreadID threadId
The thread to which this line/instruction belongs.
Definition: dyn_inst.hh:89
panic
#define panic(...)
This implements a cprintf based panic() function.
Definition: logging.hh:178
gem5::minor::Fetch2::predictBranch
void predictBranch(MinorDynInstPtr inst, BranchData &branch)
Predicts branches for the given instruction.
Definition: fetch2.cc:192

Generated on Wed May 4 2022 12:13:53 for gem5 by doxygen 1.8.17