src/cpu/simple/timing.cc

   1 /*
   2  * Copyright (c) 2002-2005 The Regents of The University of Michigan
   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: Steve Reinhardt
  29  */
  30
  31 #include "arch/locked_mem.hh"
  32 #include "arch/mmaped_ipr.hh"
  33 #include "arch/utility.hh"
  34 #include "base/bigint.hh"
  35 #include "cpu/exetrace.hh"
  36 #include "cpu/simple/timing.hh"
  37 #include "mem/packet.hh"
  38 #include "mem/packet_access.hh"
  39 #include "params/TimingSimpleCPU.hh"
  40 #include "sim/system.hh"
  41
  42 using namespace std;
  43 using namespace TheISA;
  44
  45 Port *
  46 TimingSimpleCPU::getPort(const std::string &if_name, int idx)
  47 {
  48     if (if_name == "dcache_port")
  49         return &dcachePort;
  50     else if (if_name == "icache_port")
  51         return &icachePort;
  52     else
  53         panic("No Such Port\n");
  54 }
  55
  56 void
  57 TimingSimpleCPU::init()
  58 {
  59     BaseCPU::init();
  60     cpuId = tc->readCpuId();
  61 #if FULL_SYSTEM
  62     for (int i = 0; i < threadContexts.size(); ++i) {
  63         ThreadContext *tc = threadContexts[i];
  64
  65         // initialize CPU, including PC
  66         TheISA::initCPU(tc, cpuId);
  67     }
  68 #endif
  69 }
  70
  71 Tick
  72 TimingSimpleCPU::CpuPort::recvAtomic(PacketPtr pkt)
  73 {
  74     panic("TimingSimpleCPU doesn't expect recvAtomic callback!");
  75     return curTick;
  76 }
  77
  78 void
  79 TimingSimpleCPU::CpuPort::recvFunctional(PacketPtr pkt)
  80 {
  81     //No internal storage to update, jusst return
  82     return;
  83 }
  84
  85 void
  86 TimingSimpleCPU::CpuPort::recvStatusChange(Status status)
  87 {
  88     if (status == RangeChange) {
  89         if (!snoopRangeSent) {
  90             snoopRangeSent = true;
  91             sendStatusChange(Port::RangeChange);
  92         }
  93         return;
  94     }
  95
  96     panic("TimingSimpleCPU doesn't expect recvStatusChange callback!");
  97 }
  98
  99
 100 void
 101 TimingSimpleCPU::CpuPort::TickEvent::schedule(PacketPtr _pkt, Tick t)
 102 {
 103     pkt = _pkt;
 104     Event::schedule(t);
 105 }
 106
 107 TimingSimpleCPU::TimingSimpleCPU(Params *p)
 108     : BaseSimpleCPU(p), icachePort(this, p->clock), dcachePort(this, p->clock)
 109 {
 110     _status = Idle;
 111
 112     icachePort.snoopRangeSent = false;
 113     dcachePort.snoopRangeSent = false;
 114
 115     ifetch_pkt = dcache_pkt = NULL;
 116     drainEvent = NULL;
 117     fetchEvent = NULL;
 118     previousTick = 0;
 119     changeState(SimObject::Running);
 120 }
 121
 122
 123 TimingSimpleCPU::~TimingSimpleCPU()
 124 {
 125 }
 126
 127 void
 128 TimingSimpleCPU::serialize(ostream &os)
 129 {
 130     SimObject::State so_state = SimObject::getState();
 131     SERIALIZE_ENUM(so_state);
 132     BaseSimpleCPU::serialize(os);
 133 }
 134
 135 void
 136 TimingSimpleCPU::unserialize(Checkpoint *cp, const string &section)
 137 {
 138     SimObject::State so_state;
 139     UNSERIALIZE_ENUM(so_state);
 140     BaseSimpleCPU::unserialize(cp, section);
 141 }
 142
 143 unsigned int
 144 TimingSimpleCPU::drain(Event *drain_event)
 145 {
 146     // TimingSimpleCPU is ready to drain if it's not waiting for
 147     // an access to complete.
 148     if (status() == Idle || status() == Running || status() == SwitchedOut) {
 149         changeState(SimObject::Drained);
 150         return 0;
 151     } else {
 152         changeState(SimObject::Draining);
 153         drainEvent = drain_event;
 154         return 1;
 155     }
 156 }
 157
 158 void
 159 TimingSimpleCPU::resume()
 160 {
 161     DPRINTF(SimpleCPU, "Resume\n");
 162     if (_status != SwitchedOut && _status != Idle) {
 163         assert(system->getMemoryMode() == Enums::timing);
 164
 165         // Delete the old event if it existed.
 166         if (fetchEvent) {
 167             if (fetchEvent->scheduled())
 168                 fetchEvent->deschedule();
 169
 170             delete fetchEvent;
 171         }
 172
 173         fetchEvent = new FetchEvent(this, nextCycle());
 174     }
 175
 176     changeState(SimObject::Running);
 177 }
 178
 179 void
 180 TimingSimpleCPU::switchOut()
 181 {
 182     assert(status() == Running || status() == Idle);
 183     _status = SwitchedOut;
 184     numCycles += tickToCycles(curTick - previousTick);
 185
 186     // If we've been scheduled to resume but are then told to switch out,
 187     // we'll need to cancel it.
 188     if (fetchEvent && fetchEvent->scheduled())
 189         fetchEvent->deschedule();
 190 }
 191
 192
 193 void
 194 TimingSimpleCPU::takeOverFrom(BaseCPU *oldCPU)
 195 {
 196     BaseCPU::takeOverFrom(oldCPU, &icachePort, &dcachePort);
 197
 198     // if any of this CPU's ThreadContexts are active, mark the CPU as
 199     // running and schedule its tick event.
 200     for (int i = 0; i < threadContexts.size(); ++i) {
 201         ThreadContext *tc = threadContexts[i];
 202         if (tc->status() == ThreadContext::Active && _status != Running) {
 203             _status = Running;
 204             break;
 205         }
 206     }
 207
 208     if (_status != Running) {
 209         _status = Idle;
 210     }
 211     assert(threadContexts.size() == 1);
 212     cpuId = tc->readCpuId();
 213     previousTick = curTick;
 214 }
 215
 216
 217 void
 218 TimingSimpleCPU::activateContext(int thread_num, int delay)
 219 {
 220     DPRINTF(SimpleCPU, "ActivateContext %d (%d cycles)\n", thread_num, delay);
 221
 222     assert(thread_num == 0);
 223     assert(thread);
 224
 225     assert(_status == Idle);
 226
 227     notIdleFraction++;
 228     _status = Running;
 229
 230     // kick things off by initiating the fetch of the next instruction
 231     fetchEvent = new FetchEvent(this, nextCycle(curTick + ticks(delay)));
 232 }
 233
 234
 235 void
 236 TimingSimpleCPU::suspendContext(int thread_num)
 237 {
 238     DPRINTF(SimpleCPU, "SuspendContext %d\n", thread_num);
 239
 240     assert(thread_num == 0);
 241     assert(thread);
 242
 243     assert(_status == Running);
 244
 245     // just change status to Idle... if status != Running,
 246     // completeInst() will not initiate fetch of next instruction.
 247
 248     notIdleFraction--;
 249     _status = Idle;
 250 }
 251
 252
 253 template <class T>
 254 Fault
 255 TimingSimpleCPU::read(Addr addr, T &data, unsigned flags)
 256 {
 257     Request *req =
 258         new Request(/* asid */ 0, addr, sizeof(T), flags, thread->readPC(),
 259                     cpuId, /* thread ID */ 0);
 260
 261     if (traceData) {
 262         traceData->setAddr(req->getVaddr());
 263     }
 264
 265    // translate to physical address
 266     Fault fault = thread->translateDataReadReq(req);
 267
 268     // Now do the access.
 269     if (fault == NoFault) {
 270         PacketPtr pkt =
 271             new Packet(req,
 272                        (req->isLocked() ?
 273                         MemCmd::LoadLockedReq : MemCmd::ReadReq),
 274                        Packet::Broadcast);
 275         pkt->dataDynamic<T>(new T);
 276
 277         if (req->isMmapedIpr()) {
 278             Tick delay;
 279             delay = TheISA::handleIprRead(thread->getTC(), pkt);
 280             new IprEvent(pkt, this, nextCycle(curTick + delay));
 281             _status = DcacheWaitResponse;
 282             dcache_pkt = NULL;
 283         } else if (!dcachePort.sendTiming(pkt)) {
 284             _status = DcacheRetry;
 285             dcache_pkt = pkt;
 286         } else {
 287             _status = DcacheWaitResponse;
 288             // memory system takes ownership of packet
 289             dcache_pkt = NULL;
 290         }
 291
 292         // This will need a new way to tell if it has a dcache attached.
 293         if (req->isUncacheable())
 294             recordEvent("Uncached Read");
 295     } else {
 296         delete req;
 297     }
 298
 299     return fault;
 300 }
 301
 302 Fault
 303 TimingSimpleCPU::translateDataReadAddr(Addr vaddr, Addr &paddr,
 304         int size, unsigned flags)
 305 {
 306     Request *req =
 307         new Request(0, vaddr, size, flags, thread->readPC(), cpuId, 0);
 308
 309     if (traceData) {
 310         traceData->setAddr(vaddr);
 311     }
 312
 313     Fault fault = thread->translateDataWriteReq(req);
 314
 315     if (fault == NoFault)
 316         paddr = req->getPaddr();
 317
 318     delete req;
 319     return fault;
 320 }
 321
 322 #ifndef DOXYGEN_SHOULD_SKIP_THIS
 323
 324 template
 325 Fault
 326 TimingSimpleCPU::read(Addr addr, Twin64_t &data, unsigned flags);
 327
 328 template
 329 Fault
 330 TimingSimpleCPU::read(Addr addr, Twin32_t &data, unsigned flags);
 331
 332 template
 333 Fault
 334 TimingSimpleCPU::read(Addr addr, uint64_t &data, unsigned flags);
 335
 336 template
 337 Fault
 338 TimingSimpleCPU::read(Addr addr, uint32_t &data, unsigned flags);
 339
 340 template
 341 Fault
 342 TimingSimpleCPU::read(Addr addr, uint16_t &data, unsigned flags);
 343
 344 template
 345 Fault
 346 TimingSimpleCPU::read(Addr addr, uint8_t &data, unsigned flags);
 347
 348 #endif //DOXYGEN_SHOULD_SKIP_THIS
 349
 350 template<>
 351 Fault
 352 TimingSimpleCPU::read(Addr addr, double &data, unsigned flags)
 353 {
 354     return read(addr, *(uint64_t*)&data, flags);
 355 }
 356
 357 template<>
 358 Fault
 359 TimingSimpleCPU::read(Addr addr, float &data, unsigned flags)
 360 {
 361     return read(addr, *(uint32_t*)&data, flags);
 362 }
 363
 364
 365 template<>
 366 Fault
 367 TimingSimpleCPU::read(Addr addr, int32_t &data, unsigned flags)
 368 {
 369     return read(addr, (uint32_t&)data, flags);
 370 }
 371
 372
 373 template <class T>
 374 Fault
 375 TimingSimpleCPU::write(T data, Addr addr, unsigned flags, uint64_t *res)
 376 {
 377     Request *req =
 378         new Request(/* asid */ 0, addr, sizeof(T), flags, thread->readPC(),
 379                     cpuId, /* thread ID */ 0);
 380
 381     if (traceData) {
 382         traceData->setAddr(req->getVaddr());
 383     }
 384
 385     // translate to physical address
 386     Fault fault = thread->translateDataWriteReq(req);
 387
 388     // Now do the access.
 389     if (fault == NoFault) {
 390         MemCmd cmd = MemCmd::WriteReq; // default
 391         bool do_access = true;  // flag to suppress cache access
 392
 393         if (req->isLocked()) {
 394             cmd = MemCmd::StoreCondReq;
 395             do_access = TheISA::handleLockedWrite(thread, req);
 396         } else if (req->isSwap()) {
 397             cmd = MemCmd::SwapReq;
 398             if (req->isCondSwap()) {
 399                 assert(res);
 400                 req->setExtraData(*res);
 401             }
 402         }
 403
 404         // Note: need to allocate dcache_pkt even if do_access is
 405         // false, as it's used unconditionally to call completeAcc().
 406         assert(dcache_pkt == NULL);
 407         dcache_pkt = new Packet(req, cmd, Packet::Broadcast);
 408         dcache_pkt->allocate();
 409         dcache_pkt->set(data);
 410
 411         if (do_access) {
 412             if (req->isMmapedIpr()) {
 413                 Tick delay;
 414                 dcache_pkt->set(htog(data));
 415                 delay = TheISA::handleIprWrite(thread->getTC(), dcache_pkt);
 416                 new IprEvent(dcache_pkt, this, nextCycle(curTick + delay));
 417                 _status = DcacheWaitResponse;
 418                 dcache_pkt = NULL;
 419             } else if (!dcachePort.sendTiming(dcache_pkt)) {
 420                 _status = DcacheRetry;
 421             } else {
 422                 _status = DcacheWaitResponse;
 423                 // memory system takes ownership of packet
 424                 dcache_pkt = NULL;
 425             }
 426         }
 427         // This will need a new way to tell if it's hooked up to a cache or not.
 428         if (req->isUncacheable())
 429             recordEvent("Uncached Write");
 430     } else {
 431         delete req;
 432     }
 433
 434
 435     // If the write needs to have a fault on the access, consider calling
 436     // changeStatus() and changing it to "bad addr write" or something.
 437     return fault;
 438 }
 439
 440 Fault
 441 TimingSimpleCPU::translateDataWriteAddr(Addr vaddr, Addr &paddr,
 442         int size, unsigned flags)
 443 {
 444     Request *req =
 445         new Request(0, vaddr, size, flags, thread->readPC(), cpuId, 0);
 446
 447     if (traceData) {
 448         traceData->setAddr(vaddr);
 449     }
 450
 451     Fault fault = thread->translateDataWriteReq(req);
 452
 453     if (fault == NoFault)
 454         paddr = req->getPaddr();
 455
 456     delete req;
 457     return fault;
 458 }
 459
 460
 461 #ifndef DOXYGEN_SHOULD_SKIP_THIS
 462 template
 463 Fault
 464 TimingSimpleCPU::write(Twin32_t data, Addr addr,
 465                        unsigned flags, uint64_t *res);
 466
 467 template
 468 Fault
 469 TimingSimpleCPU::write(Twin64_t data, Addr addr,
 470                        unsigned flags, uint64_t *res);
 471
 472 template
 473 Fault
 474 TimingSimpleCPU::write(uint64_t data, Addr addr,
 475                        unsigned flags, uint64_t *res);
 476
 477 template
 478 Fault
 479 TimingSimpleCPU::write(uint32_t data, Addr addr,
 480                        unsigned flags, uint64_t *res);
 481
 482 template
 483 Fault
 484 TimingSimpleCPU::write(uint16_t data, Addr addr,
 485                        unsigned flags, uint64_t *res);
 486
 487 template
 488 Fault
 489 TimingSimpleCPU::write(uint8_t data, Addr addr,
 490                        unsigned flags, uint64_t *res);
 491
 492 #endif //DOXYGEN_SHOULD_SKIP_THIS
 493
 494 template<>
 495 Fault
 496 TimingSimpleCPU::write(double data, Addr addr, unsigned flags, uint64_t *res)
 497 {
 498     return write(*(uint64_t*)&data, addr, flags, res);
 499 }
 500
 501 template<>
 502 Fault
 503 TimingSimpleCPU::write(float data, Addr addr, unsigned flags, uint64_t *res)
 504 {
 505     return write(*(uint32_t*)&data, addr, flags, res);
 506 }
 507
 508
 509 template<>
 510 Fault
 511 TimingSimpleCPU::write(int32_t data, Addr addr, unsigned flags, uint64_t *res)
 512 {
 513     return write((uint32_t)data, addr, flags, res);
 514 }
 515
 516
 517 void
 518 TimingSimpleCPU::fetch()
 519 {
 520     DPRINTF(SimpleCPU, "Fetch\n");
 521
 522     if (!curStaticInst || !curStaticInst->isDelayedCommit())
 523         checkForInterrupts();
 524
 525     Request *ifetch_req = new Request();
 526     ifetch_req->setThreadContext(cpuId, /* thread ID */ 0);
 527     Fault fault = setupFetchRequest(ifetch_req);
 528
 529     ifetch_pkt = new Packet(ifetch_req, MemCmd::ReadReq, Packet::Broadcast);
 530     ifetch_pkt->dataStatic(&inst);
 531
 532     if (fault == NoFault) {
 533         if (!icachePort.sendTiming(ifetch_pkt)) {
 534             // Need to wait for retry
 535             _status = IcacheRetry;
 536         } else {
 537             // Need to wait for cache to respond
 538             _status = IcacheWaitResponse;
 539             // ownership of packet transferred to memory system
 540             ifetch_pkt = NULL;
 541         }
 542     } else {
 543         delete ifetch_req;
 544         delete ifetch_pkt;
 545         // fetch fault: advance directly to next instruction (fault handler)
 546         advanceInst(fault);
 547     }
 548
 549     numCycles += tickToCycles(curTick - previousTick);
 550     previousTick = curTick;
 551 }
 552
 553
 554 void
 555 TimingSimpleCPU::advanceInst(Fault fault)
 556 {
 557     advancePC(fault);
 558
 559     if (_status == Running) {
 560         // kick off fetch of next instruction... callback from icache
 561         // response will cause that instruction to be executed,
 562         // keeping the CPU running.
 563         fetch();
 564     }
 565 }
 566
 567
 568 void
 569 TimingSimpleCPU::completeIfetch(PacketPtr pkt)
 570 {
 571     DPRINTF(SimpleCPU, "Complete ICache Fetch\n");
 572
 573     // received a response from the icache: execute the received
 574     // instruction
 575     assert(!pkt->isError());
 576     assert(_status == IcacheWaitResponse);
 577
 578     _status = Running;
 579
 580     numCycles += tickToCycles(curTick - previousTick);
 581     previousTick = curTick;
 582
 583     if (getState() == SimObject::Draining) {
 584         delete pkt->req;
 585         delete pkt;
 586
 587         completeDrain();
 588         return;
 589     }
 590
 591     preExecute();
 592     if (curStaticInst->isMemRef() && !curStaticInst->isDataPrefetch()) {
 593         // load or store: just send to dcache
 594         Fault fault = curStaticInst->initiateAcc(this, traceData);
 595         if (_status != Running) {
 596             // instruction will complete in dcache response callback
 597             assert(_status == DcacheWaitResponse || _status == DcacheRetry);
 598             assert(fault == NoFault);
 599         } else {
 600             if (fault == NoFault) {
 601                 // Note that ARM can have NULL packets if the instruction gets
 602                 // squashed due to predication
 603                 // early fail on store conditional: complete now
 604                 assert(dcache_pkt != NULL || THE_ISA == ARM_ISA);
 605
 606                 fault = curStaticInst->completeAcc(dcache_pkt, this,
 607                                                    traceData);
 608                 if (dcache_pkt != NULL)
 609                 {
 610                     delete dcache_pkt->req;
 611                     delete dcache_pkt;
 612                     dcache_pkt = NULL;
 613                 }
 614
 615                 // keep an instruction count
 616                 if (fault == NoFault)
 617                     countInst();
 618             } else if (traceData) {
 619                 // If there was a fault, we shouldn't trace this instruction.
 620                 delete traceData;
 621                 traceData = NULL;
 622             }
 623
 624             postExecute();
 625             // @todo remove me after debugging with legion done
 626             if (curStaticInst && (!curStaticInst->isMicroop() ||
 627                         curStaticInst->isFirstMicroop()))
 628                 instCnt++;
 629             advanceInst(fault);
 630         }
 631     } else {
 632         // non-memory instruction: execute completely now
 633         Fault fault = curStaticInst->execute(this, traceData);
 634
 635         // keep an instruction count
 636         if (fault == NoFault)
 637             countInst();
 638         else if (traceData) {
 639             // If there was a fault, we shouldn't trace this instruction.
 640             delete traceData;
 641             traceData = NULL;
 642         }
 643
 644         postExecute();
 645         // @todo remove me after debugging with legion done
 646         if (curStaticInst && (!curStaticInst->isMicroop() ||
 647                     curStaticInst->isFirstMicroop()))
 648             instCnt++;
 649         advanceInst(fault);
 650     }
 651
 652     delete pkt->req;
 653     delete pkt;
 654 }
 655
 656 void
 657 TimingSimpleCPU::IcachePort::ITickEvent::process()
 658 {
 659     cpu->completeIfetch(pkt);
 660 }
 661
 662 bool
 663 TimingSimpleCPU::IcachePort::recvTiming(PacketPtr pkt)
 664 {
 665     if (pkt->isResponse() && !pkt->wasNacked()) {
 666         // delay processing of returned data until next CPU clock edge
 667         Tick next_tick = cpu->nextCycle(curTick);
 668
 669         if (next_tick == curTick)
 670             cpu->completeIfetch(pkt);
 671         else
 672             tickEvent.schedule(pkt, next_tick);
 673
 674         return true;
 675     }
 676     else if (pkt->wasNacked()) {
 677         assert(cpu->_status == IcacheWaitResponse);
 678         pkt->reinitNacked();
 679         if (!sendTiming(pkt)) {
 680             cpu->_status = IcacheRetry;
 681             cpu->ifetch_pkt = pkt;
 682         }
 683     }
 684     //Snooping a Coherence Request, do nothing
 685     return true;
 686 }
 687
 688 void
 689 TimingSimpleCPU::IcachePort::recvRetry()
 690 {
 691     // we shouldn't get a retry unless we have a packet that we're
 692     // waiting to transmit
 693     assert(cpu->ifetch_pkt != NULL);
 694     assert(cpu->_status == IcacheRetry);
 695     PacketPtr tmp = cpu->ifetch_pkt;
 696     if (sendTiming(tmp)) {
 697         cpu->_status = IcacheWaitResponse;
 698         cpu->ifetch_pkt = NULL;
 699     }
 700 }
 701
 702 void
 703 TimingSimpleCPU::completeDataAccess(PacketPtr pkt)
 704 {
 705     // received a response from the dcache: complete the load or store
 706     // instruction
 707     assert(!pkt->isError());
 708     assert(_status == DcacheWaitResponse);
 709     _status = Running;
 710
 711     numCycles += tickToCycles(curTick - previousTick);
 712     previousTick = curTick;
 713
 714     Fault fault = curStaticInst->completeAcc(pkt, this, traceData);
 715
 716     // keep an instruction count
 717     if (fault == NoFault)
 718         countInst();
 719     else if (traceData) {
 720         // If there was a fault, we shouldn't trace this instruction.
 721         delete traceData;
 722         traceData = NULL;
 723     }
 724
 725     if (pkt->isRead() && pkt->isLocked()) {
 726         TheISA::handleLockedRead(thread, pkt->req);
 727     }
 728
 729     delete pkt->req;
 730     delete pkt;
 731
 732     postExecute();
 733
 734     if (getState() == SimObject::Draining) {
 735         advancePC(fault);
 736         completeDrain();
 737
 738         return;
 739     }
 740
 741     advanceInst(fault);
 742 }
 743
 744
 745 void
 746 TimingSimpleCPU::completeDrain()
 747 {
 748     DPRINTF(Config, "Done draining\n");
 749     changeState(SimObject::Drained);
 750     drainEvent->process();
 751 }
 752
 753 void
 754 TimingSimpleCPU::DcachePort::setPeer(Port *port)
 755 {
 756     Port::setPeer(port);
 757
 758 #if FULL_SYSTEM
 759     // Update the ThreadContext's memory ports (Functional/Virtual
 760     // Ports)
 761     cpu->tcBase()->connectMemPorts();
 762 #endif
 763 }
 764
 765 bool
 766 TimingSimpleCPU::DcachePort::recvTiming(PacketPtr pkt)
 767 {
 768     if (pkt->isResponse() && !pkt->wasNacked()) {
 769         // delay processing of returned data until next CPU clock edge
 770         Tick next_tick = cpu->nextCycle(curTick);
 771
 772         if (next_tick == curTick)
 773             cpu->completeDataAccess(pkt);
 774         else
 775             tickEvent.schedule(pkt, next_tick);
 776
 777         return true;
 778     }
 779     else if (pkt->wasNacked()) {
 780         assert(cpu->_status == DcacheWaitResponse);
 781         pkt->reinitNacked();
 782         if (!sendTiming(pkt)) {
 783             cpu->_status = DcacheRetry;
 784             cpu->dcache_pkt = pkt;
 785         }
 786     }
 787     //Snooping a Coherence Request, do nothing
 788     return true;
 789 }
 790
 791 void
 792 TimingSimpleCPU::DcachePort::DTickEvent::process()
 793 {
 794     cpu->completeDataAccess(pkt);
 795 }
 796
 797 void
 798 TimingSimpleCPU::DcachePort::recvRetry()
 799 {
 800     // we shouldn't get a retry unless we have a packet that we're
 801     // waiting to transmit
 802     assert(cpu->dcache_pkt != NULL);
 803     assert(cpu->_status == DcacheRetry);
 804     PacketPtr tmp = cpu->dcache_pkt;
 805     if (sendTiming(tmp)) {
 806         cpu->_status = DcacheWaitResponse;
 807         // memory system takes ownership of packet
 808         cpu->dcache_pkt = NULL;
 809     }
 810 }
 811
 812 TimingSimpleCPU::IprEvent::IprEvent(Packet *_pkt, TimingSimpleCPU *_cpu, Tick t)
 813     : Event(&mainEventQueue), pkt(_pkt), cpu(_cpu)
 814 {
 815     schedule(t);
 816 }
 817
 818 void
 819 TimingSimpleCPU::IprEvent::process()
 820 {
 821     cpu->completeDataAccess(pkt);
 822 }
 823
 824 const char *
 825 TimingSimpleCPU::IprEvent::description() const
 826 {
 827     return "Timing Simple CPU Delay IPR event";
 828 }
 829
 830
 831 void
 832 TimingSimpleCPU::printAddr(Addr a)
 833 {
 834     dcachePort.printAddr(a);
 835 }
 836
 837
 838 ////////////////////////////////////////////////////////////////////////
 839 //
 840 //  TimingSimpleCPU Simulation Object
 841 //
 842 TimingSimpleCPU *
 843 TimingSimpleCPUParams::create()
 844 {
 845     TimingSimpleCPU::Params *params = new TimingSimpleCPU::Params();
 846     params->name = name;
 847     params->numberOfThreads = 1;
 848     params->max_insts_any_thread = max_insts_any_thread;
 849     params->max_insts_all_threads = max_insts_all_threads;
 850     params->max_loads_any_thread = max_loads_any_thread;
 851     params->max_loads_all_threads = max_loads_all_threads;
 852     params->progress_interval = progress_interval;
 853     params->deferRegistration = defer_registration;
 854     params->clock = clock;
 855     params->phase = phase;
 856     params->functionTrace = function_trace;
 857     params->functionTraceStart = function_trace_start;
 858     params->system = system;
 859     params->cpu_id = cpu_id;
 860     params->tracer = tracer;
 861
 862     params->itb = itb;
 863     params->dtb = dtb;
 864 #if FULL_SYSTEM
 865     params->profile = profile;
 866     params->do_quiesce = do_quiesce;
 867     params->do_checkpoint_insts = do_checkpoint_insts;
 868     params->do_statistics_insts = do_statistics_insts;
 869 #else
 870     if (workload.size() != 1)
 871         panic("only one workload allowed");
 872     params->process = workload[0];
 873 #endif
 874
 875     TimingSimpleCPU *cpu = new TimingSimpleCPU(params);
 876     return cpu;
 877 }