2 * Copyright (c) 2010-2012 ARM Limited
3 * Copyright (c) 2013 Advanced Micro Devices, Inc.
6 * The license below extends only to copyright in the software and shall
7 * not be construed as granting a license to any other intellectual
8 * property including but not limited to intellectual property relating
9 * to a hardware implementation of the functionality of the software
10 * licensed hereunder. You may use the software subject to the license
11 * terms below provided that you ensure that this notice is replicated
12 * unmodified and in its entirety in all distributions of the software,
13 * modified or unmodified, in source code or in binary form.
15 * Copyright (c) 2002-2005 The Regents of The University of Michigan
16 * All rights reserved.
18 * Redistribution and use in source and binary forms, with or without
19 * modification, are permitted provided that the following conditions are
20 * met: redistributions of source code must retain the above copyright
21 * notice, this list of conditions and the following disclaimer;
22 * redistributions in binary form must reproduce the above copyright
23 * notice, this list of conditions and the following disclaimer in the
24 * documentation and/or other materials provided with the distribution;
25 * neither the name of the copyright holders nor the names of its
26 * contributors may be used to endorse or promote products derived from
27 * this software without specific prior written permission.
29 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
30 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
31 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
32 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
33 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
34 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
35 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
36 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
37 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
38 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
39 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
41 * Authors: Steve Reinhardt
44 #include "arch/kernel_stats.hh"
45 #include "arch/stacktrace.hh"
46 #include "arch/tlb.hh"
47 #include "arch/utility.hh"
48 #include "arch/vtophys.hh"
49 #include "base/loader/symtab.hh"
50 #include "base/cp_annotate.hh"
51 #include "base/cprintf.hh"
52 #include "base/inifile.hh"
53 #include "base/misc.hh"
54 #include "base/pollevent.hh"
55 #include "base/trace.hh"
56 #include "base/types.hh"
57 #include "config/the_isa.hh"
58 #include "cpu/simple/base.hh"
59 #include "cpu/base.hh"
60 #include "cpu/checker/cpu.hh"
61 #include "cpu/checker/thread_context.hh"
62 #include "cpu/exetrace.hh"
63 #include "cpu/pred/bpred_unit.hh"
64 #include "cpu/profile.hh"
65 #include "cpu/simple_thread.hh"
67 #include "cpu/static_inst.hh"
68 #include "cpu/thread_context.hh"
69 #include "debug/Decode.hh"
70 #include "debug/Fetch.hh"
71 #include "debug/Quiesce.hh"
72 #include "mem/mem_object.hh"
73 #include "mem/packet.hh"
74 #include "mem/request.hh"
75 #include "params/BaseSimpleCPU.hh"
76 #include "sim/byteswap.hh"
77 #include "sim/debug.hh"
78 #include "sim/faults.hh"
79 #include "sim/full_system.hh"
80 #include "sim/sim_events.hh"
81 #include "sim/sim_object.hh"
82 #include "sim/stats.hh"
83 #include "sim/system.hh"
86 using namespace TheISA
;
88 BaseSimpleCPU::BaseSimpleCPU(BaseSimpleCPUParams
*p
)
90 branchPred(p
->branchPred
),
91 traceData(NULL
), thread(NULL
)
94 thread
= new SimpleThread(this, 0, p
->system
, p
->itb
, p
->dtb
,
97 thread
= new SimpleThread(this, /* thread_num */ 0, p
->system
,
98 p
->workload
[0], p
->itb
, p
->dtb
, p
->isa
[0]);
100 thread
->setStatus(ThreadContext::Halted
);
102 tc
= thread
->getTC();
105 BaseCPU
*temp_checker
= p
->checker
;
106 checker
= dynamic_cast<CheckerCPU
*>(temp_checker
);
107 checker
->setSystem(p
->system
);
108 // Manipulate thread context
109 ThreadContext
*cpu_tc
= tc
;
110 tc
= new CheckerThreadContext
<ThreadContext
>(cpu_tc
, this->checker
);
124 threadContexts
.push_back(tc
);
131 BaseSimpleCPU::~BaseSimpleCPU()
136 BaseSimpleCPU::haltContext(ThreadID thread_num
)
138 // for now, these are equivalent
139 suspendContext(thread_num
);
144 BaseSimpleCPU::regStats()
146 using namespace Stats
;
151 .name(name() + ".committedInsts")
152 .desc("Number of instructions committed")
156 .name(name() + ".committedOps")
157 .desc("Number of ops (including micro ops) committed")
161 .name(name() + ".num_int_alu_accesses")
162 .desc("Number of integer alu accesses")
166 .name(name() + ".num_fp_alu_accesses")
167 .desc("Number of float alu accesses")
171 .name(name() + ".num_func_calls")
172 .desc("number of times a function call or return occured")
176 .name(name() + ".num_conditional_control_insts")
177 .desc("number of instructions that are conditional controls")
181 .name(name() + ".num_int_insts")
182 .desc("number of integer instructions")
186 .name(name() + ".num_fp_insts")
187 .desc("number of float instructions")
191 .name(name() + ".num_int_register_reads")
192 .desc("number of times the integer registers were read")
196 .name(name() + ".num_int_register_writes")
197 .desc("number of times the integer registers were written")
201 .name(name() + ".num_fp_register_reads")
202 .desc("number of times the floating registers were read")
206 .name(name() + ".num_fp_register_writes")
207 .desc("number of times the floating registers were written")
211 .name(name() + ".num_cc_register_reads")
212 .desc("number of times the CC registers were read")
217 .name(name() + ".num_cc_register_writes")
218 .desc("number of times the CC registers were written")
223 .name(name()+".num_mem_refs")
224 .desc("number of memory refs")
228 .name(name() + ".num_store_insts")
229 .desc("Number of store instructions")
233 .name(name() + ".num_load_insts")
234 .desc("Number of load instructions")
238 .name(name() + ".not_idle_fraction")
239 .desc("Percentage of non-idle cycles")
243 .name(name() + ".idle_fraction")
244 .desc("Percentage of idle cycles")
248 .name(name() + ".num_busy_cycles")
249 .desc("Number of busy cycles")
253 .name(name()+".num_idle_cycles")
254 .desc("Number of idle cycles")
258 .name(name() + ".icache_stall_cycles")
259 .desc("ICache total stall cycles")
260 .prereq(icacheStallCycles
)
264 .name(name() + ".dcache_stall_cycles")
265 .desc("DCache total stall cycles")
266 .prereq(dcacheStallCycles
)
270 .name(name() + ".icache_retry_cycles")
271 .desc("ICache total retry cycles")
272 .prereq(icacheRetryCycles
)
276 .name(name() + ".dcache_retry_cycles")
277 .desc("DCache total retry cycles")
278 .prereq(dcacheRetryCycles
)
282 .init(Enums::Num_OpClass
)
283 .name(name() + ".op_class")
284 .desc("Class of executed instruction")
285 .flags(total
| pdf
| dist
)
287 for (unsigned i
= 0; i
< Num_OpClasses
; ++i
) {
288 statExecutedInstType
.subname(i
, Enums::OpClassStrings
[i
]);
291 idleFraction
= constant(1.0) - notIdleFraction
;
292 numIdleCycles
= idleFraction
* numCycles
;
293 numBusyCycles
= (notIdleFraction
)*numCycles
;
296 .name(name() + ".Branches")
297 .desc("Number of branches fetched")
298 .prereq(numBranches
);
301 .name(name() + ".predictedBranches")
302 .desc("Number of branches predicted as taken")
303 .prereq(numPredictedBranches
);
306 .name(name() + ".BranchMispred")
307 .desc("Number of branch mispredictions")
308 .prereq(numBranchMispred
);
312 BaseSimpleCPU::resetStats()
314 // startNumInst = numInst;
315 notIdleFraction
= (_status
!= Idle
);
319 BaseSimpleCPU::serializeThread(ostream
&os
, ThreadID tid
)
321 assert(_status
== Idle
|| _status
== Running
);
324 thread
->serialize(os
);
328 BaseSimpleCPU::unserializeThread(Checkpoint
*cp
, const string
§ion
,
332 fatal("Trying to load more than one thread into a SimpleCPU\n");
333 thread
->unserialize(cp
, section
);
337 change_thread_state(ThreadID tid
, int activate
, int priority
)
342 BaseSimpleCPU::dbg_vtophys(Addr addr
)
344 return vtophys(tc
, addr
);
348 BaseSimpleCPU::wakeup()
350 if (thread
->status() != ThreadContext::Suspended
)
353 DPRINTF(Quiesce
,"Suspended Processor awoke\n");
358 BaseSimpleCPU::checkForInterrupts()
360 if (checkInterrupts(tc
)) {
361 Fault interrupt
= interrupts
->getInterrupt(tc
);
363 if (interrupt
!= NoFault
) {
365 interrupts
->updateIntrInfo(tc
);
366 interrupt
->invoke(tc
);
367 thread
->decoder
.reset();
374 BaseSimpleCPU::setupFetchRequest(Request
*req
)
376 Addr instAddr
= thread
->instAddr();
378 // set up memory request for instruction fetch
379 DPRINTF(Fetch
, "Fetch: PC:%08p\n", instAddr
);
381 Addr fetchPC
= (instAddr
& PCMask
) + fetchOffset
;
382 req
->setVirt(0, fetchPC
, sizeof(MachInst
), Request::INST_FETCH
, instMasterId(),
388 BaseSimpleCPU::preExecute()
390 // maintain $r0 semantics
391 thread
->setIntReg(ZeroReg
, 0);
392 #if THE_ISA == ALPHA_ISA
393 thread
->setFloatReg(ZeroReg
, 0.0);
396 // check for instruction-count-based events
397 comInstEventQueue
[0]->serviceEvents(numInst
);
398 system
->instEventQueue
.serviceEvents(system
->totalNumInsts
);
400 // decode the instruction
403 TheISA::PCState pcState
= thread
->pcState();
405 if (isRomMicroPC(pcState
.microPC())) {
407 curStaticInst
= microcodeRom
.fetchMicroop(pcState
.microPC(),
409 } else if (!curMacroStaticInst
) {
410 //We're not in the middle of a macro instruction
411 StaticInstPtr instPtr
= NULL
;
413 TheISA::Decoder
*decoder
= &(thread
->decoder
);
415 //Predecode, ie bundle up an ExtMachInst
416 //If more fetch data is needed, pass it in.
417 Addr fetchPC
= (pcState
.instAddr() & PCMask
) + fetchOffset
;
418 //if(decoder->needMoreBytes())
419 decoder
->moreBytes(pcState
, fetchPC
, inst
);
421 // decoder->process();
423 //Decode an instruction if one is ready. Otherwise, we'll have to
424 //fetch beyond the MachInst at the current pc.
425 instPtr
= decoder
->decode(pcState
);
428 thread
->pcState(pcState
);
431 fetchOffset
+= sizeof(MachInst
);
434 //If we decoded an instruction and it's microcoded, start pulling
436 if (instPtr
&& instPtr
->isMacroop()) {
437 curMacroStaticInst
= instPtr
;
438 curStaticInst
= curMacroStaticInst
->fetchMicroop(pcState
.microPC());
440 curStaticInst
= instPtr
;
443 //Read the next micro op from the macro op
444 curStaticInst
= curMacroStaticInst
->fetchMicroop(pcState
.microPC());
447 //If we decoded an instruction this "tick", record information about it.
450 traceData
= tracer
->getInstRecord(curTick(), tc
,
451 curStaticInst
, thread
->pcState(), curMacroStaticInst
);
453 DPRINTF(Decode
,"Decode: Decoded %s instruction: %#x\n",
454 curStaticInst
->getName(), curStaticInst
->machInst
);
458 if (branchPred
&& curStaticInst
&& curStaticInst
->isControl()) {
459 // Use a fake sequence number since we only have one
460 // instruction in flight at the same time.
461 const InstSeqNum
cur_sn(0);
462 const ThreadID
tid(0);
463 pred_pc
= thread
->pcState();
464 const bool predict_taken(
465 branchPred
->predict(curStaticInst
, cur_sn
, pred_pc
, tid
));
468 ++numPredictedBranches
;
473 BaseSimpleCPU::postExecute()
475 assert(curStaticInst
);
477 TheISA::PCState pc
= tc
->pcState();
478 Addr instAddr
= pc
.instAddr();
479 if (FullSystem
&& thread
->profile
) {
480 bool usermode
= TheISA::inUserMode(tc
);
481 thread
->profilePC
= usermode
? 1 : instAddr
;
482 ProfileNode
*node
= thread
->profile
->consume(tc
, curStaticInst
);
484 thread
->profileNode
= node
;
487 if (curStaticInst
->isMemRef()) {
491 if (curStaticInst
->isLoad()) {
493 comLoadEventQueue
[0]->serviceEvents(numLoad
);
496 if (CPA::available()) {
497 CPA::cpa()->swAutoBegin(tc
, pc
.nextInstAddr());
500 if (curStaticInst
->isControl()) {
504 /* Power model statistics */
505 //integer alu accesses
506 if (curStaticInst
->isInteger()){
512 if (curStaticInst
->isFloating()){
517 //number of function calls/returns to get window accesses
518 if (curStaticInst
->isCall() || curStaticInst
->isReturn()){
522 //the number of branch predictions that will be made
523 if (curStaticInst
->isCondCtrl()){
528 if (curStaticInst
->isLoad()){
532 if (curStaticInst
->isStore()){
535 /* End power model statistics */
537 statExecutedInstType
[curStaticInst
->opClass()]++;
540 traceFunctions(instAddr
);
548 // Call CPU instruction commit probes
549 probeInstCommit(curStaticInst
);
553 BaseSimpleCPU::advancePC(const Fault
&fault
)
555 const bool branching(thread
->pcState().branching());
557 //Since we're moving to a new pc, zero out the offset
559 if (fault
!= NoFault
) {
560 curMacroStaticInst
= StaticInst::nullStaticInstPtr
;
561 fault
->invoke(tc
, curStaticInst
);
562 thread
->decoder
.reset();
565 if (curStaticInst
->isLastMicroop())
566 curMacroStaticInst
= StaticInst::nullStaticInstPtr
;
567 TheISA::PCState pcState
= thread
->pcState();
568 TheISA::advancePC(pcState
, curStaticInst
);
569 thread
->pcState(pcState
);
573 if (branchPred
&& curStaticInst
&& curStaticInst
->isControl()) {
574 // Use a fake sequence number since we only have one
575 // instruction in flight at the same time.
576 const InstSeqNum
cur_sn(0);
577 const ThreadID
tid(0);
579 if (pred_pc
== thread
->pcState()) {
580 // Correctly predicted branch
581 branchPred
->update(cur_sn
, tid
);
583 // Mis-predicted branch
584 branchPred
->squash(cur_sn
, pcState(),
592 BaseSimpleCPU::startup()