1/*
2 * Copyright 2014 Google, Inc.
3 * Copyright (c) 2012-2013,2015 ARM Limited
4 * All rights reserved.
5 *
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.
14 *
15 * Copyright (c) 2002-2005 The Regents of The University of Michigan
16 * All rights reserved.
17 *
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.
28 *
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.
40 *
41 * Authors: Steve Reinhardt
42 */
43
44#include "arch/locked_mem.hh"
45#include "arch/mmapped_ipr.hh"
46#include "arch/utility.hh"
47#include "base/bigint.hh"
48#include "base/output.hh"
49#include "config/the_isa.hh"
50#include "cpu/simple/atomic.hh"
51#include "cpu/exetrace.hh"
52#include "debug/Drain.hh"
53#include "debug/ExecFaulting.hh"
54#include "debug/SimpleCPU.hh"
55#include "mem/packet.hh"
56#include "mem/packet_access.hh"
57#include "mem/physical.hh"
58#include "params/AtomicSimpleCPU.hh"
59#include "sim/faults.hh"
60#include "sim/system.hh"
61#include "sim/full_system.hh"
62
63using namespace std;
64using namespace TheISA;
65
66AtomicSimpleCPU::TickEvent::TickEvent(AtomicSimpleCPU *c)
67 : Event(CPU_Tick_Pri), cpu(c)
68{
69}
70
71
72void
73AtomicSimpleCPU::TickEvent::process()
74{
75 cpu->tick();
76}
77
78const char *
79AtomicSimpleCPU::TickEvent::description() const
80{
81 return "AtomicSimpleCPU tick";
82}
83
84void
85AtomicSimpleCPU::init()
86{
87 BaseSimpleCPU::init();
88
89 int cid = threadContexts[0]->contextId();
90 ifetch_req.setThreadContext(cid, 0);
91 data_read_req.setThreadContext(cid, 0);
92 data_write_req.setThreadContext(cid, 0);
93}
94
95AtomicSimpleCPU::AtomicSimpleCPU(AtomicSimpleCPUParams *p)
96 : BaseSimpleCPU(p), tickEvent(this), width(p->width), locked(false),
97 simulate_data_stalls(p->simulate_data_stalls),
98 simulate_inst_stalls(p->simulate_inst_stalls),
99 icachePort(name() + ".icache_port", this),
100 dcachePort(name() + ".dcache_port", this),
101 fastmem(p->fastmem), dcache_access(false), dcache_latency(0),
102 ppCommit(nullptr)
103{
104 _status = Idle;
105}
106
107
108AtomicSimpleCPU::~AtomicSimpleCPU()
109{
110 if (tickEvent.scheduled()) {
111 deschedule(tickEvent);
112 }
113}
114
115DrainState
116AtomicSimpleCPU::drain()
117{
118 if (switchedOut())
119 return DrainState::Drained;
120
121 if (!isDrained()) {
122 DPRINTF(Drain, "Requesting drain.\n");
123 return DrainState::Draining;
124 } else {
125 if (tickEvent.scheduled())
126 deschedule(tickEvent);
127
128 activeThreads.clear();
129 DPRINTF(Drain, "Not executing microcode, no need to drain.\n");
130 return DrainState::Drained;
131 }
132}
133
134void
135AtomicSimpleCPU::threadSnoop(PacketPtr pkt, ThreadID sender)
136{
137 DPRINTF(SimpleCPU, "received snoop pkt for addr:%#x %s\n", pkt->getAddr(),
138 pkt->cmdString());
139
140 for (ThreadID tid = 0; tid < numThreads; tid++) {
141 if (tid != sender) {
142 if(getCpuAddrMonitor(tid)->doMonitor(pkt)) {
143 wakeup(tid);
144 }
145
146 TheISA::handleLockedSnoop(threadInfo[tid]->thread,
147 pkt, dcachePort.cacheBlockMask);
148 }
149 }
150}
151
152void
153AtomicSimpleCPU::drainResume()
154{
155 assert(!tickEvent.scheduled());
156 if (switchedOut())
157 return;
158
159 DPRINTF(SimpleCPU, "Resume\n");
160 verifyMemoryMode();
161
162 assert(!threadContexts.empty());
163
164 _status = BaseSimpleCPU::Idle;
165
166 for (ThreadID tid = 0; tid < numThreads; tid++) {
167 if (threadInfo[tid]->thread->status() == ThreadContext::Active) {
168 threadInfo[tid]->notIdleFraction = 1;
169 activeThreads.push_back(tid);
170 _status = BaseSimpleCPU::Running;
171
172 // Tick if any threads active
173 if (!tickEvent.scheduled()) {
174 schedule(tickEvent, nextCycle());
175 }
176 } else {
177 threadInfo[tid]->notIdleFraction = 0;
178 }
179 }
180}
181
182bool
183AtomicSimpleCPU::tryCompleteDrain()
184{
185 if (drainState() != DrainState::Draining)
186 return false;
187
188 DPRINTF(Drain, "tryCompleteDrain.\n");
189 if (!isDrained())
190 return false;
191
192 DPRINTF(Drain, "CPU done draining, processing drain event\n");
193 signalDrainDone();
194
195 return true;
196}
197
198
199void
200AtomicSimpleCPU::switchOut()
201{
202 BaseSimpleCPU::switchOut();
203
204 assert(!tickEvent.scheduled());
205 assert(_status == BaseSimpleCPU::Running || _status == Idle);
206 assert(isDrained());
207}
208
209
210void
211AtomicSimpleCPU::takeOverFrom(BaseCPU *oldCPU)
212{
213 BaseSimpleCPU::takeOverFrom(oldCPU);
214
215 // The tick event should have been descheduled by drain()
216 assert(!tickEvent.scheduled());
217}
218
219void
220AtomicSimpleCPU::verifyMemoryMode() const
221{
222 if (!system->isAtomicMode()) {
223 fatal("The atomic CPU requires the memory system to be in "
224 "'atomic' mode.\n");
225 }
226}
227
228void
229AtomicSimpleCPU::activateContext(ThreadID thread_num)
230{
231 DPRINTF(SimpleCPU, "ActivateContext %d\n", thread_num);
232
233 assert(thread_num < numThreads);
234
235 threadInfo[thread_num]->notIdleFraction = 1;
236 Cycles delta = ticksToCycles(threadInfo[thread_num]->thread->lastActivate -
237 threadInfo[thread_num]->thread->lastSuspend);
238 numCycles += delta;
239 ppCycles->notify(delta);
240
241 if (!tickEvent.scheduled()) {
242 //Make sure ticks are still on multiples of cycles
243 schedule(tickEvent, clockEdge(Cycles(0)));
244 }
245 _status = BaseSimpleCPU::Running;
246 if (std::find(activeThreads.begin(), activeThreads.end(), thread_num)
247 == activeThreads.end()) {
248 activeThreads.push_back(thread_num);
249 }
250}
251
252
253void
254AtomicSimpleCPU::suspendContext(ThreadID thread_num)
255{
256 DPRINTF(SimpleCPU, "SuspendContext %d\n", thread_num);
257
258 assert(thread_num < numThreads);
259 activeThreads.remove(thread_num);
260
261 if (_status == Idle)
262 return;
263
264 assert(_status == BaseSimpleCPU::Running);
265
266 threadInfo[thread_num]->notIdleFraction = 0;
267
268 if (activeThreads.empty()) {
269 _status = Idle;
270
271 if (tickEvent.scheduled()) {
272 deschedule(tickEvent);
273 }
274 }
275
276}
277
278
279Tick
280AtomicSimpleCPU::AtomicCPUDPort::recvAtomicSnoop(PacketPtr pkt)
281{
282 DPRINTF(SimpleCPU, "received snoop pkt for addr:%#x %s\n", pkt->getAddr(),
283 pkt->cmdString());
284
285 // X86 ISA: Snooping an invalidation for monitor/mwait
286 AtomicSimpleCPU *cpu = (AtomicSimpleCPU *)(&owner);
287
288 for (ThreadID tid = 0; tid < cpu->numThreads; tid++) {
289 if (cpu->getCpuAddrMonitor(tid)->doMonitor(pkt)) {
290 cpu->wakeup(tid);
291 }
292 }
293
294 // if snoop invalidates, release any associated locks
295 if (pkt->isInvalidate()) {
296 DPRINTF(SimpleCPU, "received invalidation for addr:%#x\n",
297 pkt->getAddr());
298 for (auto &t_info : cpu->threadInfo) {
299 TheISA::handleLockedSnoop(t_info->thread, pkt, cacheBlockMask);
300 }
301 }
302
303 return 0;
304}
305
306void
307AtomicSimpleCPU::AtomicCPUDPort::recvFunctionalSnoop(PacketPtr pkt)
308{
309 DPRINTF(SimpleCPU, "received snoop pkt for addr:%#x %s\n", pkt->getAddr(),
310 pkt->cmdString());
311
312 // X86 ISA: Snooping an invalidation for monitor/mwait
313 AtomicSimpleCPU *cpu = (AtomicSimpleCPU *)(&owner);
314 for (ThreadID tid = 0; tid < cpu->numThreads; tid++) {
315 if(cpu->getCpuAddrMonitor(tid)->doMonitor(pkt)) {
316 cpu->wakeup(tid);
317 }
318 }
319
320 // if snoop invalidates, release any associated locks
321 if (pkt->isInvalidate()) {
322 DPRINTF(SimpleCPU, "received invalidation for addr:%#x\n",
323 pkt->getAddr());
324 for (auto &t_info : cpu->threadInfo) {
325 TheISA::handleLockedSnoop(t_info->thread, pkt, cacheBlockMask);
326 }
327 }
328}
329
330Fault
331AtomicSimpleCPU::readMem(Addr addr, uint8_t * data,
332 unsigned size, unsigned flags)
333{
334 SimpleExecContext& t_info = *threadInfo[curThread];
335 SimpleThread* thread = t_info.thread;
336
337 // use the CPU's statically allocated read request and packet objects
338 Request *req = &data_read_req;
339
340 if (traceData)
341 traceData->setMem(addr, size, flags);
342
343 //The size of the data we're trying to read.
344 int fullSize = size;
345
346 //The address of the second part of this access if it needs to be split
347 //across a cache line boundary.
348 Addr secondAddr = roundDown(addr + size - 1, cacheLineSize());
349
350 if (secondAddr > addr)
351 size = secondAddr - addr;
352
353 dcache_latency = 0;
354
355 req->taskId(taskId());
356 while (1) {
357 req->setVirt(0, addr, size, flags, dataMasterId(), thread->pcState().instAddr());
358
359 // translate to physical address
360 Fault fault = thread->dtb->translateAtomic(req, thread->getTC(),
361 BaseTLB::Read);
362
363 // Now do the access.
364 if (fault == NoFault && !req->getFlags().isSet(Request::NO_ACCESS)) {
365 Packet pkt(req, Packet::makeReadCmd(req));
366 pkt.dataStatic(data);
367
368 if (req->isMmappedIpr())
369 dcache_latency += TheISA::handleIprRead(thread->getTC(), &pkt);
370 else {
371 if (fastmem && system->isMemAddr(pkt.getAddr()))
372 system->getPhysMem().access(&pkt);
373 else
374 dcache_latency += dcachePort.sendAtomic(&pkt);
375 }
376 dcache_access = true;
377
378 assert(!pkt.isError());
379
380 if (req->isLLSC()) {
381 TheISA::handleLockedRead(thread, req);
382 }
383 }
384
385 //If there's a fault, return it
386 if (fault != NoFault) {
387 if (req->isPrefetch()) {
388 return NoFault;
389 } else {
390 return fault;
391 }
392 }
393
394 //If we don't need to access a second cache line, stop now.
395 if (secondAddr <= addr)
396 {
397 if (req->isLockedRMW() && fault == NoFault) {
398 assert(!locked);
399 locked = true;
400 }
401
402 return fault;
403 }
404
405 /*
406 * Set up for accessing the second cache line.
407 */
408
409 //Move the pointer we're reading into to the correct location.
410 data += size;
411 //Adjust the size to get the remaining bytes.
412 size = addr + fullSize - secondAddr;
413 //And access the right address.
414 addr = secondAddr;
415 }
416}
417
|
424
425Fault
426AtomicSimpleCPU::writeMem(uint8_t *data, unsigned size,
427 Addr addr, unsigned flags, uint64_t *res)
428{
429 SimpleExecContext& t_info = *threadInfo[curThread];
430 SimpleThread* thread = t_info.thread;
431 static uint8_t zero_array[64] = {};
432
433 if (data == NULL) {
434 assert(size <= 64);
435 assert(flags & Request::CACHE_BLOCK_ZERO);
436 // This must be a cache block cleaning request
437 data = zero_array;
438 }
439
440 // use the CPU's statically allocated write request and packet objects
441 Request *req = &data_write_req;
442
443 if (traceData)
444 traceData->setMem(addr, size, flags);
445
446 //The size of the data we're trying to read.
447 int fullSize = size;
448
449 //The address of the second part of this access if it needs to be split
450 //across a cache line boundary.
451 Addr secondAddr = roundDown(addr + size - 1, cacheLineSize());
452
453 if(secondAddr > addr)
454 size = secondAddr - addr;
455
456 dcache_latency = 0;
457
458 req->taskId(taskId());
459 while(1) {
460 req->setVirt(0, addr, size, flags, dataMasterId(), thread->pcState().instAddr());
461
462 // translate to physical address
463 Fault fault = thread->dtb->translateAtomic(req, thread->getTC(), BaseTLB::Write);
464
465 // Now do the access.
466 if (fault == NoFault) {
467 MemCmd cmd = MemCmd::WriteReq; // default
468 bool do_access = true; // flag to suppress cache access
469
470 if (req->isLLSC()) {
471 cmd = MemCmd::StoreCondReq;
472 do_access = TheISA::handleLockedWrite(thread, req, dcachePort.cacheBlockMask);
473 } else if (req->isSwap()) {
474 cmd = MemCmd::SwapReq;
475 if (req->isCondSwap()) {
476 assert(res);
477 req->setExtraData(*res);
478 }
479 }
480
481 if (do_access && !req->getFlags().isSet(Request::NO_ACCESS)) {
482 Packet pkt = Packet(req, cmd);
483 pkt.dataStatic(data);
484
485 if (req->isMmappedIpr()) {
486 dcache_latency +=
487 TheISA::handleIprWrite(thread->getTC(), &pkt);
488 } else {
489 if (fastmem && system->isMemAddr(pkt.getAddr()))
490 system->getPhysMem().access(&pkt);
491 else
492 dcache_latency += dcachePort.sendAtomic(&pkt);
493
494 // Notify other threads on this CPU of write
495 threadSnoop(&pkt, curThread);
496 }
497 dcache_access = true;
498 assert(!pkt.isError());
499
500 if (req->isSwap()) {
501 assert(res);
502 memcpy(res, pkt.getConstPtr<uint8_t>(), fullSize);
503 }
504 }
505
506 if (res && !req->isSwap()) {
507 *res = req->getExtraData();
508 }
509 }
510
511 //If there's a fault or we don't need to access a second cache line,
512 //stop now.
513 if (fault != NoFault || secondAddr <= addr)
514 {
515 if (req->isLockedRMW() && fault == NoFault) {
516 assert(locked);
517 locked = false;
518 }
519
520
521 if (fault != NoFault && req->isPrefetch()) {
522 return NoFault;
523 } else {
524 return fault;
525 }
526 }
527
528 /*
529 * Set up for accessing the second cache line.
530 */
531
532 //Move the pointer we're reading into to the correct location.
533 data += size;
534 //Adjust the size to get the remaining bytes.
535 size = addr + fullSize - secondAddr;
536 //And access the right address.
537 addr = secondAddr;
538 }
539}
540
541
542void
543AtomicSimpleCPU::tick()
544{
545 DPRINTF(SimpleCPU, "Tick\n");
546
547 // Change thread if multi-threaded
548 swapActiveThread();
549
550 // Set memroy request ids to current thread
551 if (numThreads > 1) {
552 ContextID cid = threadContexts[curThread]->contextId();
553
554 ifetch_req.setThreadContext(cid, curThread);
555 data_read_req.setThreadContext(cid, curThread);
556 data_write_req.setThreadContext(cid, curThread);
557 }
558
559 SimpleExecContext& t_info = *threadInfo[curThread];
560 SimpleThread* thread = t_info.thread;
561
562 Tick latency = 0;
563
564 for (int i = 0; i < width || locked; ++i) {
565 numCycles++;
566 ppCycles->notify(1);
567
568 if (!curStaticInst || !curStaticInst->isDelayedCommit()) {
569 checkForInterrupts();
570 checkPcEventQueue();
571 }
572
573 // We must have just got suspended by a PC event
574 if (_status == Idle) {
575 tryCompleteDrain();
576 return;
577 }
578
579 Fault fault = NoFault;
580
581 TheISA::PCState pcState = thread->pcState();
582
583 bool needToFetch = !isRomMicroPC(pcState.microPC()) &&
584 !curMacroStaticInst;
585 if (needToFetch) {
586 ifetch_req.taskId(taskId());
587 setupFetchRequest(&ifetch_req);
588 fault = thread->itb->translateAtomic(&ifetch_req, thread->getTC(),
589 BaseTLB::Execute);
590 }
591
592 if (fault == NoFault) {
593 Tick icache_latency = 0;
594 bool icache_access = false;
595 dcache_access = false; // assume no dcache access
596
597 if (needToFetch) {
598 // This is commented out because the decoder would act like
599 // a tiny cache otherwise. It wouldn't be flushed when needed
600 // like the I cache. It should be flushed, and when that works
601 // this code should be uncommented.
602 //Fetch more instruction memory if necessary
603 //if(decoder.needMoreBytes())
604 //{
605 icache_access = true;
606 Packet ifetch_pkt = Packet(&ifetch_req, MemCmd::ReadReq);
607 ifetch_pkt.dataStatic(&inst);
608
609 if (fastmem && system->isMemAddr(ifetch_pkt.getAddr()))
610 system->getPhysMem().access(&ifetch_pkt);
611 else
612 icache_latency = icachePort.sendAtomic(&ifetch_pkt);
613
614 assert(!ifetch_pkt.isError());
615
616 // ifetch_req is initialized to read the instruction directly
617 // into the CPU object's inst field.
618 //}
619 }
620
621 preExecute();
622
623 if (curStaticInst) {
624 fault = curStaticInst->execute(&t_info, traceData);
625
626 // keep an instruction count
627 if (fault == NoFault) {
628 countInst();
629 ppCommit->notify(std::make_pair(thread, curStaticInst));
630 }
631 else if (traceData && !DTRACE(ExecFaulting)) {
632 delete traceData;
633 traceData = NULL;
634 }
635
636 postExecute();
637 }
638
639 // @todo remove me after debugging with legion done
640 if (curStaticInst && (!curStaticInst->isMicroop() ||
641 curStaticInst->isFirstMicroop()))
642 instCnt++;
643
644 Tick stall_ticks = 0;
645 if (simulate_inst_stalls && icache_access)
646 stall_ticks += icache_latency;
647
648 if (simulate_data_stalls && dcache_access)
649 stall_ticks += dcache_latency;
650
651 if (stall_ticks) {
652 // the atomic cpu does its accounting in ticks, so
653 // keep counting in ticks but round to the clock
654 // period
655 latency += divCeil(stall_ticks, clockPeriod()) *
656 clockPeriod();
657 }
658
659 }
660 if(fault != NoFault || !t_info.stayAtPC)
661 advancePC(fault);
662 }
663
664 if (tryCompleteDrain())
665 return;
666
667 // instruction takes at least one cycle
668 if (latency < clockPeriod())
669 latency = clockPeriod();
670
671 if (_status != Idle)
672 reschedule(tickEvent, curTick() + latency, true);
673}
674
675void
676AtomicSimpleCPU::regProbePoints()
677{
678 BaseCPU::regProbePoints();
679
680 ppCommit = new ProbePointArg<pair<SimpleThread*, const StaticInstPtr>>
681 (getProbeManager(), "Commit");
682}
683
684void
685AtomicSimpleCPU::printAddr(Addr a)
686{
687 dcachePort.printAddr(a);
688}
689
690////////////////////////////////////////////////////////////////////////
691//
692// AtomicSimpleCPU Simulation Object
693//
694AtomicSimpleCPU *
695AtomicSimpleCPUParams::create()
696{
697 return new AtomicSimpleCPU(this);
698}
|