atomic.cc revision 4224
12623SN/A/*
22623SN/A * Copyright (c) 2002-2005 The Regents of The University of Michigan
32623SN/A * All rights reserved.
42623SN/A *
52623SN/A * Redistribution and use in source and binary forms, with or without
62623SN/A * modification, are permitted provided that the following conditions are
72623SN/A * met: redistributions of source code must retain the above copyright
82623SN/A * notice, this list of conditions and the following disclaimer;
92623SN/A * redistributions in binary form must reproduce the above copyright
102623SN/A * notice, this list of conditions and the following disclaimer in the
112623SN/A * documentation and/or other materials provided with the distribution;
122623SN/A * neither the name of the copyright holders nor the names of its
132623SN/A * contributors may be used to endorse or promote products derived from
142623SN/A * this software without specific prior written permission.
152623SN/A *
162623SN/A * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
172623SN/A * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
182623SN/A * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
192623SN/A * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
202623SN/A * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
212623SN/A * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
222623SN/A * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
232623SN/A * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
242623SN/A * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
252623SN/A * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
262623SN/A * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
272665Ssaidi@eecs.umich.edu *
282665Ssaidi@eecs.umich.edu * Authors: Steve Reinhardt
292623SN/A */
302623SN/A
313170Sstever@eecs.umich.edu#include "arch/locked_mem.hh"
323806Ssaidi@eecs.umich.edu#include "arch/mmaped_ipr.hh"
332623SN/A#include "arch/utility.hh"
344040Ssaidi@eecs.umich.edu#include "base/bigint.hh"
352623SN/A#include "cpu/exetrace.hh"
362623SN/A#include "cpu/simple/atomic.hh"
373348Sbinkertn@umich.edu#include "mem/packet.hh"
383348Sbinkertn@umich.edu#include "mem/packet_access.hh"
392623SN/A#include "sim/builder.hh"
402901Ssaidi@eecs.umich.edu#include "sim/system.hh"
412623SN/A
422623SN/Ausing namespace std;
432623SN/Ausing namespace TheISA;
442623SN/A
452623SN/AAtomicSimpleCPU::TickEvent::TickEvent(AtomicSimpleCPU *c)
462623SN/A    : Event(&mainEventQueue, CPU_Tick_Pri), cpu(c)
472623SN/A{
482623SN/A}
492623SN/A
502623SN/A
512623SN/Avoid
522623SN/AAtomicSimpleCPU::TickEvent::process()
532623SN/A{
542623SN/A    cpu->tick();
552623SN/A}
562623SN/A
572623SN/Aconst char *
582623SN/AAtomicSimpleCPU::TickEvent::description()
592623SN/A{
602623SN/A    return "AtomicSimpleCPU tick event";
612623SN/A}
622623SN/A
632856Srdreslin@umich.eduPort *
642856Srdreslin@umich.eduAtomicSimpleCPU::getPort(const std::string &if_name, int idx)
652856Srdreslin@umich.edu{
662856Srdreslin@umich.edu    if (if_name == "dcache_port")
672856Srdreslin@umich.edu        return &dcachePort;
682856Srdreslin@umich.edu    else if (if_name == "icache_port")
692856Srdreslin@umich.edu        return &icachePort;
702856Srdreslin@umich.edu    else
712856Srdreslin@umich.edu        panic("No Such Port\n");
722856Srdreslin@umich.edu}
732623SN/A
742623SN/Avoid
752623SN/AAtomicSimpleCPU::init()
762623SN/A{
772623SN/A    BaseCPU::init();
782623SN/A#if FULL_SYSTEM
792680Sktlim@umich.edu    for (int i = 0; i < threadContexts.size(); ++i) {
802680Sktlim@umich.edu        ThreadContext *tc = threadContexts[i];
812623SN/A
822623SN/A        // initialize CPU, including PC
832680Sktlim@umich.edu        TheISA::initCPU(tc, tc->readCpuId());
842623SN/A    }
852623SN/A#endif
862623SN/A}
872623SN/A
882623SN/Abool
893349Sbinkertn@umich.eduAtomicSimpleCPU::CpuPort::recvTiming(PacketPtr pkt)
902623SN/A{
913184Srdreslin@umich.edu    panic("AtomicSimpleCPU doesn't expect recvTiming callback!");
922623SN/A    return true;
932623SN/A}
942623SN/A
952623SN/ATick
963349Sbinkertn@umich.eduAtomicSimpleCPU::CpuPort::recvAtomic(PacketPtr pkt)
972623SN/A{
983310Srdreslin@umich.edu    //Snooping a coherence request, just return
993649Srdreslin@umich.edu    return 0;
1002623SN/A}
1012623SN/A
1022623SN/Avoid
1033349Sbinkertn@umich.eduAtomicSimpleCPU::CpuPort::recvFunctional(PacketPtr pkt)
1042623SN/A{
1053184Srdreslin@umich.edu    //No internal storage to update, just return
1063184Srdreslin@umich.edu    return;
1072623SN/A}
1082623SN/A
1092623SN/Avoid
1102623SN/AAtomicSimpleCPU::CpuPort::recvStatusChange(Status status)
1112623SN/A{
1123647Srdreslin@umich.edu    if (status == RangeChange) {
1133647Srdreslin@umich.edu        if (!snoopRangeSent) {
1143647Srdreslin@umich.edu            snoopRangeSent = true;
1153647Srdreslin@umich.edu            sendStatusChange(Port::RangeChange);
1163647Srdreslin@umich.edu        }
1172626SN/A        return;
1183647Srdreslin@umich.edu    }
1192626SN/A
1202623SN/A    panic("AtomicSimpleCPU doesn't expect recvStatusChange callback!");
1212623SN/A}
1222623SN/A
1232657Ssaidi@eecs.umich.eduvoid
1242623SN/AAtomicSimpleCPU::CpuPort::recvRetry()
1252623SN/A{
1262623SN/A    panic("AtomicSimpleCPU doesn't expect recvRetry callback!");
1272623SN/A}
1282623SN/A
1294192Sktlim@umich.eduvoid
1304192Sktlim@umich.eduAtomicSimpleCPU::DcachePort::setPeer(Port *port)
1314192Sktlim@umich.edu{
1324192Sktlim@umich.edu    Port::setPeer(port);
1334192Sktlim@umich.edu
1344192Sktlim@umich.edu#if FULL_SYSTEM
1354192Sktlim@umich.edu    // Update the ThreadContext's memory ports (Functional/Virtual
1364192Sktlim@umich.edu    // Ports)
1374192Sktlim@umich.edu    cpu->tcBase()->connectMemPorts();
1384192Sktlim@umich.edu#endif
1394192Sktlim@umich.edu}
1402623SN/A
1412623SN/AAtomicSimpleCPU::AtomicSimpleCPU(Params *p)
1422623SN/A    : BaseSimpleCPU(p), tickEvent(this),
1432623SN/A      width(p->width), simulate_stalls(p->simulate_stalls),
1442640Sstever@eecs.umich.edu      icachePort(name() + "-iport", this), dcachePort(name() + "-iport", this)
1452623SN/A{
1462623SN/A    _status = Idle;
1472623SN/A
1483647Srdreslin@umich.edu    icachePort.snoopRangeSent = false;
1493647Srdreslin@umich.edu    dcachePort.snoopRangeSent = false;
1503647Srdreslin@umich.edu
1512663Sstever@eecs.umich.edu    ifetch_req = new Request();
1523170Sstever@eecs.umich.edu    ifetch_req->setThreadContext(p->cpu_id, 0); // Add thread ID if we add MT
1534022Sstever@eecs.umich.edu    ifetch_pkt = new Packet(ifetch_req, MemCmd::ReadReq, Packet::Broadcast);
1542623SN/A    ifetch_pkt->dataStatic(&inst);
1552623SN/A
1562663Sstever@eecs.umich.edu    data_read_req = new Request();
1573170Sstever@eecs.umich.edu    data_read_req->setThreadContext(p->cpu_id, 0); // Add thread ID here too
1584022Sstever@eecs.umich.edu    data_read_pkt = new Packet(data_read_req, MemCmd::ReadReq,
1592641Sstever@eecs.umich.edu                               Packet::Broadcast);
1602623SN/A    data_read_pkt->dataStatic(&dataReg);
1612623SN/A
1622663Sstever@eecs.umich.edu    data_write_req = new Request();
1633170Sstever@eecs.umich.edu    data_write_req->setThreadContext(p->cpu_id, 0); // Add thread ID here too
1644022Sstever@eecs.umich.edu    data_write_pkt = new Packet(data_write_req, MemCmd::WriteReq,
1652641Sstever@eecs.umich.edu                                Packet::Broadcast);
1664040Ssaidi@eecs.umich.edu    data_swap_pkt = new Packet(data_write_req, MemCmd::SwapReq,
1674040Ssaidi@eecs.umich.edu                                Packet::Broadcast);
1682623SN/A}
1692623SN/A
1702623SN/A
1712623SN/AAtomicSimpleCPU::~AtomicSimpleCPU()
1722623SN/A{
1732623SN/A}
1742623SN/A
1752623SN/Avoid
1762623SN/AAtomicSimpleCPU::serialize(ostream &os)
1772623SN/A{
1782915Sktlim@umich.edu    SimObject::State so_state = SimObject::getState();
1792915Sktlim@umich.edu    SERIALIZE_ENUM(so_state);
1803177Shsul@eecs.umich.edu    Status _status = status();
1813177Shsul@eecs.umich.edu    SERIALIZE_ENUM(_status);
1823145Shsul@eecs.umich.edu    BaseSimpleCPU::serialize(os);
1832623SN/A    nameOut(os, csprintf("%s.tickEvent", name()));
1842623SN/A    tickEvent.serialize(os);
1852623SN/A}
1862623SN/A
1872623SN/Avoid
1882623SN/AAtomicSimpleCPU::unserialize(Checkpoint *cp, const string &section)
1892623SN/A{
1902915Sktlim@umich.edu    SimObject::State so_state;
1912915Sktlim@umich.edu    UNSERIALIZE_ENUM(so_state);
1923177Shsul@eecs.umich.edu    UNSERIALIZE_ENUM(_status);
1933145Shsul@eecs.umich.edu    BaseSimpleCPU::unserialize(cp, section);
1942915Sktlim@umich.edu    tickEvent.unserialize(cp, csprintf("%s.tickEvent", section));
1952915Sktlim@umich.edu}
1962915Sktlim@umich.edu
1972915Sktlim@umich.eduvoid
1982915Sktlim@umich.eduAtomicSimpleCPU::resume()
1992915Sktlim@umich.edu{
2003324Shsul@eecs.umich.edu    if (_status != SwitchedOut && _status != Idle) {
2013201Shsul@eecs.umich.edu        assert(system->getMemoryMode() == System::Atomic);
2023324Shsul@eecs.umich.edu
2033324Shsul@eecs.umich.edu        changeState(SimObject::Running);
2043324Shsul@eecs.umich.edu        if (thread->status() == ThreadContext::Active) {
2053431Sgblack@eecs.umich.edu            if (!tickEvent.scheduled()) {
2063495Sktlim@umich.edu                tickEvent.schedule(nextCycle());
2073431Sgblack@eecs.umich.edu            }
2083324Shsul@eecs.umich.edu        }
2092915Sktlim@umich.edu    }
2102623SN/A}
2112623SN/A
2122623SN/Avoid
2132798Sktlim@umich.eduAtomicSimpleCPU::switchOut()
2142623SN/A{
2152798Sktlim@umich.edu    assert(status() == Running || status() == Idle);
2162798Sktlim@umich.edu    _status = SwitchedOut;
2172623SN/A
2182798Sktlim@umich.edu    tickEvent.squash();
2192623SN/A}
2202623SN/A
2212623SN/A
2222623SN/Avoid
2232623SN/AAtomicSimpleCPU::takeOverFrom(BaseCPU *oldCPU)
2242623SN/A{
2254192Sktlim@umich.edu    BaseCPU::takeOverFrom(oldCPU, &icachePort, &dcachePort);
2262623SN/A
2272623SN/A    assert(!tickEvent.scheduled());
2282623SN/A
2292680Sktlim@umich.edu    // if any of this CPU's ThreadContexts are active, mark the CPU as
2302623SN/A    // running and schedule its tick event.
2312680Sktlim@umich.edu    for (int i = 0; i < threadContexts.size(); ++i) {
2322680Sktlim@umich.edu        ThreadContext *tc = threadContexts[i];
2332680Sktlim@umich.edu        if (tc->status() == ThreadContext::Active && _status != Running) {
2342623SN/A            _status = Running;
2353495Sktlim@umich.edu            tickEvent.schedule(nextCycle());
2362623SN/A            break;
2372623SN/A        }
2382623SN/A    }
2393512Sktlim@umich.edu    if (_status != Running) {
2403512Sktlim@umich.edu        _status = Idle;
2413512Sktlim@umich.edu    }
2422623SN/A}
2432623SN/A
2442623SN/A
2452623SN/Avoid
2462623SN/AAtomicSimpleCPU::activateContext(int thread_num, int delay)
2472623SN/A{
2482623SN/A    assert(thread_num == 0);
2492683Sktlim@umich.edu    assert(thread);
2502623SN/A
2512623SN/A    assert(_status == Idle);
2522623SN/A    assert(!tickEvent.scheduled());
2532623SN/A
2542623SN/A    notIdleFraction++;
2553686Sktlim@umich.edu
2563430Sgblack@eecs.umich.edu    //Make sure ticks are still on multiples of cycles
2573495Sktlim@umich.edu    tickEvent.schedule(nextCycle(curTick + cycles(delay)));
2582623SN/A    _status = Running;
2592623SN/A}
2602623SN/A
2612623SN/A
2622623SN/Avoid
2632623SN/AAtomicSimpleCPU::suspendContext(int thread_num)
2642623SN/A{
2652623SN/A    assert(thread_num == 0);
2662683Sktlim@umich.edu    assert(thread);
2672623SN/A
2682623SN/A    assert(_status == Running);
2692626SN/A
2702626SN/A    // tick event may not be scheduled if this gets called from inside
2712626SN/A    // an instruction's execution, e.g. "quiesce"
2722626SN/A    if (tickEvent.scheduled())
2732626SN/A        tickEvent.deschedule();
2742623SN/A
2752623SN/A    notIdleFraction--;
2762623SN/A    _status = Idle;
2772623SN/A}
2782623SN/A
2792623SN/A
2802623SN/Atemplate <class T>
2812623SN/AFault
2822623SN/AAtomicSimpleCPU::read(Addr addr, T &data, unsigned flags)
2832623SN/A{
2843169Sstever@eecs.umich.edu    // use the CPU's statically allocated read request and packet objects
2853169Sstever@eecs.umich.edu    Request *req = data_read_req;
2863349Sbinkertn@umich.edu    PacketPtr pkt = data_read_pkt;
2873169Sstever@eecs.umich.edu
2883169Sstever@eecs.umich.edu    req->setVirt(0, addr, sizeof(T), flags, thread->readPC());
2892623SN/A
2902623SN/A    if (traceData) {
2912623SN/A        traceData->setAddr(addr);
2922623SN/A    }
2932623SN/A
2942623SN/A    // translate to physical address
2953169Sstever@eecs.umich.edu    Fault fault = thread->translateDataReadReq(req);
2962623SN/A
2972623SN/A    // Now do the access.
2982623SN/A    if (fault == NoFault) {
2993169Sstever@eecs.umich.edu        pkt->reinitFromRequest();
3002623SN/A
3013806Ssaidi@eecs.umich.edu        if (req->isMmapedIpr())
3023806Ssaidi@eecs.umich.edu            dcache_latency = TheISA::handleIprRead(thread->getTC(),pkt);
3033806Ssaidi@eecs.umich.edu        else
3043806Ssaidi@eecs.umich.edu            dcache_latency = dcachePort.sendAtomic(pkt);
3052623SN/A        dcache_access = true;
3063814Ssaidi@eecs.umich.edu#if !defined(NDEBUG)
3073814Ssaidi@eecs.umich.edu        if (pkt->result != Packet::Success)
3083814Ssaidi@eecs.umich.edu            panic("Unable to find responder for address pa = %#X va = %#X\n",
3093814Ssaidi@eecs.umich.edu                    pkt->req->getPaddr(), pkt->req->getVaddr());
3103814Ssaidi@eecs.umich.edu#endif
3113169Sstever@eecs.umich.edu        data = pkt->get<T>();
3123170Sstever@eecs.umich.edu
3133170Sstever@eecs.umich.edu        if (req->isLocked()) {
3143170Sstever@eecs.umich.edu            TheISA::handleLockedRead(thread, req);
3153170Sstever@eecs.umich.edu        }
3162623SN/A    }
3172623SN/A
3182623SN/A    // This will need a new way to tell if it has a dcache attached.
3193172Sstever@eecs.umich.edu    if (req->isUncacheable())
3202623SN/A        recordEvent("Uncached Read");
3212623SN/A
3222623SN/A    return fault;
3232623SN/A}
3242623SN/A
3252623SN/A#ifndef DOXYGEN_SHOULD_SKIP_THIS
3262623SN/A
3272623SN/Atemplate
3282623SN/AFault
3294115Ssaidi@eecs.umich.eduAtomicSimpleCPU::read(Addr addr, Twin32_t &data, unsigned flags);
3304115Ssaidi@eecs.umich.edu
3314115Ssaidi@eecs.umich.edutemplate
3324115Ssaidi@eecs.umich.eduFault
3334040Ssaidi@eecs.umich.eduAtomicSimpleCPU::read(Addr addr, Twin64_t &data, unsigned flags);
3344040Ssaidi@eecs.umich.edu
3354040Ssaidi@eecs.umich.edutemplate
3364040Ssaidi@eecs.umich.eduFault
3372623SN/AAtomicSimpleCPU::read(Addr addr, uint64_t &data, unsigned flags);
3382623SN/A
3392623SN/Atemplate
3402623SN/AFault
3412623SN/AAtomicSimpleCPU::read(Addr addr, uint32_t &data, unsigned flags);
3422623SN/A
3432623SN/Atemplate
3442623SN/AFault
3452623SN/AAtomicSimpleCPU::read(Addr addr, uint16_t &data, unsigned flags);
3462623SN/A
3472623SN/Atemplate
3482623SN/AFault
3492623SN/AAtomicSimpleCPU::read(Addr addr, uint8_t &data, unsigned flags);
3502623SN/A
3512623SN/A#endif //DOXYGEN_SHOULD_SKIP_THIS
3522623SN/A
3532623SN/Atemplate<>
3542623SN/AFault
3552623SN/AAtomicSimpleCPU::read(Addr addr, double &data, unsigned flags)
3562623SN/A{
3572623SN/A    return read(addr, *(uint64_t*)&data, flags);
3582623SN/A}
3592623SN/A
3602623SN/Atemplate<>
3612623SN/AFault
3622623SN/AAtomicSimpleCPU::read(Addr addr, float &data, unsigned flags)
3632623SN/A{
3642623SN/A    return read(addr, *(uint32_t*)&data, flags);
3652623SN/A}
3662623SN/A
3672623SN/A
3682623SN/Atemplate<>
3692623SN/AFault
3702623SN/AAtomicSimpleCPU::read(Addr addr, int32_t &data, unsigned flags)
3712623SN/A{
3722623SN/A    return read(addr, (uint32_t&)data, flags);
3732623SN/A}
3742623SN/A
3752623SN/A
3762623SN/Atemplate <class T>
3772623SN/AFault
3782623SN/AAtomicSimpleCPU::write(T data, Addr addr, unsigned flags, uint64_t *res)
3792623SN/A{
3803169Sstever@eecs.umich.edu    // use the CPU's statically allocated write request and packet objects
3813169Sstever@eecs.umich.edu    Request *req = data_write_req;
3824040Ssaidi@eecs.umich.edu    PacketPtr pkt;
3833169Sstever@eecs.umich.edu
3843169Sstever@eecs.umich.edu    req->setVirt(0, addr, sizeof(T), flags, thread->readPC());
3852623SN/A
3864040Ssaidi@eecs.umich.edu    if (req->isSwap())
3874040Ssaidi@eecs.umich.edu        pkt = data_swap_pkt;
3884040Ssaidi@eecs.umich.edu    else
3894040Ssaidi@eecs.umich.edu        pkt = data_write_pkt;
3904040Ssaidi@eecs.umich.edu
3912623SN/A    if (traceData) {
3922623SN/A        traceData->setAddr(addr);
3932623SN/A    }
3942623SN/A
3952623SN/A    // translate to physical address
3963169Sstever@eecs.umich.edu    Fault fault = thread->translateDataWriteReq(req);
3972623SN/A
3982623SN/A    // Now do the access.
3992623SN/A    if (fault == NoFault) {
4003170Sstever@eecs.umich.edu        bool do_access = true;  // flag to suppress cache access
4012623SN/A
4023170Sstever@eecs.umich.edu        if (req->isLocked()) {
4033170Sstever@eecs.umich.edu            do_access = TheISA::handleLockedWrite(thread, req);
4043170Sstever@eecs.umich.edu        }
4054040Ssaidi@eecs.umich.edu        if (req->isCondSwap()) {
4064040Ssaidi@eecs.umich.edu             assert(res);
4074040Ssaidi@eecs.umich.edu             req->setExtraData(*res);
4084040Ssaidi@eecs.umich.edu        }
4094040Ssaidi@eecs.umich.edu
4102623SN/A
4113170Sstever@eecs.umich.edu        if (do_access) {
4123170Sstever@eecs.umich.edu            pkt->reinitFromRequest();
4133170Sstever@eecs.umich.edu            pkt->dataStatic(&data);
4142631SN/A
4153806Ssaidi@eecs.umich.edu            if (req->isMmapedIpr()) {
4163806Ssaidi@eecs.umich.edu                dcache_latency = TheISA::handleIprWrite(thread->getTC(), pkt);
4173806Ssaidi@eecs.umich.edu            } else {
4183806Ssaidi@eecs.umich.edu                data = htog(data);
4193806Ssaidi@eecs.umich.edu                dcache_latency = dcachePort.sendAtomic(pkt);
4203806Ssaidi@eecs.umich.edu            }
4213170Sstever@eecs.umich.edu            dcache_access = true;
4223170Sstever@eecs.umich.edu
4233814Ssaidi@eecs.umich.edu#if !defined(NDEBUG)
4243814Ssaidi@eecs.umich.edu            if (pkt->result != Packet::Success)
4253814Ssaidi@eecs.umich.edu                panic("Unable to find responder for address pa = %#X va = %#X\n",
4263814Ssaidi@eecs.umich.edu                        pkt->req->getPaddr(), pkt->req->getVaddr());
4273814Ssaidi@eecs.umich.edu#endif
4283170Sstever@eecs.umich.edu        }
4293170Sstever@eecs.umich.edu
4304040Ssaidi@eecs.umich.edu        if (req->isSwap()) {
4314040Ssaidi@eecs.umich.edu            assert(res);
4324040Ssaidi@eecs.umich.edu            *res = pkt->get<T>();
4334050Ssaidi@eecs.umich.edu        } else if (res) {
4344052Ssaidi@eecs.umich.edu            *res = req->getExtraData();
4352631SN/A        }
4362623SN/A    }
4372623SN/A
4382623SN/A    // This will need a new way to tell if it's hooked up to a cache or not.
4393172Sstever@eecs.umich.edu    if (req->isUncacheable())
4402623SN/A        recordEvent("Uncached Write");
4412623SN/A
4422623SN/A    // If the write needs to have a fault on the access, consider calling
4432623SN/A    // changeStatus() and changing it to "bad addr write" or something.
4442623SN/A    return fault;
4452623SN/A}
4462623SN/A
4472623SN/A
4482623SN/A#ifndef DOXYGEN_SHOULD_SKIP_THIS
4494224Sgblack@eecs.umich.edu
4504224Sgblack@eecs.umich.edutemplate
4514224Sgblack@eecs.umich.eduFault
4524224Sgblack@eecs.umich.eduAtomicSimpleCPU::write(Twin32_t data, Addr addr,
4534224Sgblack@eecs.umich.edu                       unsigned flags, uint64_t *res);
4544224Sgblack@eecs.umich.edu
4554224Sgblack@eecs.umich.edutemplate
4564224Sgblack@eecs.umich.eduFault
4574224Sgblack@eecs.umich.eduAtomicSimpleCPU::write(Twin64_t data, Addr addr,
4584224Sgblack@eecs.umich.edu                       unsigned flags, uint64_t *res);
4594224Sgblack@eecs.umich.edu
4602623SN/Atemplate
4612623SN/AFault
4622623SN/AAtomicSimpleCPU::write(uint64_t data, Addr addr,
4632623SN/A                       unsigned flags, uint64_t *res);
4642623SN/A
4652623SN/Atemplate
4662623SN/AFault
4672623SN/AAtomicSimpleCPU::write(uint32_t data, Addr addr,
4682623SN/A                       unsigned flags, uint64_t *res);
4692623SN/A
4702623SN/Atemplate
4712623SN/AFault
4722623SN/AAtomicSimpleCPU::write(uint16_t data, Addr addr,
4732623SN/A                       unsigned flags, uint64_t *res);
4742623SN/A
4752623SN/Atemplate
4762623SN/AFault
4772623SN/AAtomicSimpleCPU::write(uint8_t data, Addr addr,
4782623SN/A                       unsigned flags, uint64_t *res);
4792623SN/A
4802623SN/A#endif //DOXYGEN_SHOULD_SKIP_THIS
4812623SN/A
4822623SN/Atemplate<>
4832623SN/AFault
4842623SN/AAtomicSimpleCPU::write(double data, Addr addr, unsigned flags, uint64_t *res)
4852623SN/A{
4862623SN/A    return write(*(uint64_t*)&data, addr, flags, res);
4872623SN/A}
4882623SN/A
4892623SN/Atemplate<>
4902623SN/AFault
4912623SN/AAtomicSimpleCPU::write(float data, Addr addr, unsigned flags, uint64_t *res)
4922623SN/A{
4932623SN/A    return write(*(uint32_t*)&data, addr, flags, res);
4942623SN/A}
4952623SN/A
4962623SN/A
4972623SN/Atemplate<>
4982623SN/AFault
4992623SN/AAtomicSimpleCPU::write(int32_t data, Addr addr, unsigned flags, uint64_t *res)
5002623SN/A{
5012623SN/A    return write((uint32_t)data, addr, flags, res);
5022623SN/A}
5032623SN/A
5042623SN/A
5052623SN/Avoid
5062623SN/AAtomicSimpleCPU::tick()
5072623SN/A{
5082623SN/A    Tick latency = cycles(1); // instruction takes one cycle by default
5092623SN/A
5102623SN/A    for (int i = 0; i < width; ++i) {
5112623SN/A        numCycles++;
5122623SN/A
5133387Sgblack@eecs.umich.edu        if (!curStaticInst || !curStaticInst->isDelayedCommit())
5143387Sgblack@eecs.umich.edu            checkForInterrupts();
5152626SN/A
5162662Sstever@eecs.umich.edu        Fault fault = setupFetchRequest(ifetch_req);
5172623SN/A
5182623SN/A        if (fault == NoFault) {
5192662Sstever@eecs.umich.edu            ifetch_pkt->reinitFromRequest();
5202662Sstever@eecs.umich.edu
5212662Sstever@eecs.umich.edu            Tick icache_latency = icachePort.sendAtomic(ifetch_pkt);
5222623SN/A            // ifetch_req is initialized to read the instruction directly
5232623SN/A            // into the CPU object's inst field.
5242623SN/A
5252623SN/A            dcache_access = false; // assume no dcache access
5262623SN/A            preExecute();
5273814Ssaidi@eecs.umich.edu
5282623SN/A            fault = curStaticInst->execute(this, traceData);
5292623SN/A            postExecute();
5302623SN/A
5313814Ssaidi@eecs.umich.edu            // @todo remove me after debugging with legion done
5323814Ssaidi@eecs.umich.edu            if (curStaticInst && (!curStaticInst->isMicroOp() ||
5333901Ssaidi@eecs.umich.edu                        curStaticInst->isFirstMicroOp()))
5343814Ssaidi@eecs.umich.edu                instCnt++;
5353814Ssaidi@eecs.umich.edu
5362623SN/A            if (simulate_stalls) {
5372662Sstever@eecs.umich.edu                Tick icache_stall = icache_latency - cycles(1);
5382623SN/A                Tick dcache_stall =
5392662Sstever@eecs.umich.edu                    dcache_access ? dcache_latency - cycles(1) : 0;
5402803Ssaidi@eecs.umich.edu                Tick stall_cycles = (icache_stall + dcache_stall) / cycles(1);
5412803Ssaidi@eecs.umich.edu                if (cycles(stall_cycles) < (icache_stall + dcache_stall))
5422803Ssaidi@eecs.umich.edu                    latency += cycles(stall_cycles+1);
5432803Ssaidi@eecs.umich.edu                else
5442803Ssaidi@eecs.umich.edu                    latency += cycles(stall_cycles);
5452623SN/A            }
5462623SN/A
5472623SN/A        }
5482623SN/A
5492623SN/A        advancePC(fault);
5502623SN/A    }
5512623SN/A
5522626SN/A    if (_status != Idle)
5532626SN/A        tickEvent.schedule(curTick + latency);
5542623SN/A}
5552623SN/A
5562623SN/A
5572623SN/A////////////////////////////////////////////////////////////////////////
5582623SN/A//
5592623SN/A//  AtomicSimpleCPU Simulation Object
5602623SN/A//
5612623SN/ABEGIN_DECLARE_SIM_OBJECT_PARAMS(AtomicSimpleCPU)
5622623SN/A
5632623SN/A    Param<Counter> max_insts_any_thread;
5642623SN/A    Param<Counter> max_insts_all_threads;
5652623SN/A    Param<Counter> max_loads_any_thread;
5662623SN/A    Param<Counter> max_loads_all_threads;
5673119Sktlim@umich.edu    Param<Tick> progress_interval;
5682901Ssaidi@eecs.umich.edu    SimObjectParam<System *> system;
5693170Sstever@eecs.umich.edu    Param<int> cpu_id;
5702623SN/A
5712623SN/A#if FULL_SYSTEM
5723453Sgblack@eecs.umich.edu    SimObjectParam<TheISA::ITB *> itb;
5733453Sgblack@eecs.umich.edu    SimObjectParam<TheISA::DTB *> dtb;
5742623SN/A    Param<Tick> profile;
5753617Sbinkertn@umich.edu
5763617Sbinkertn@umich.edu    Param<bool> do_quiesce;
5773617Sbinkertn@umich.edu    Param<bool> do_checkpoint_insts;
5783617Sbinkertn@umich.edu    Param<bool> do_statistics_insts;
5792623SN/A#else
5802623SN/A    SimObjectParam<Process *> workload;
5812623SN/A#endif // FULL_SYSTEM
5822623SN/A
5832623SN/A    Param<int> clock;
5843661Srdreslin@umich.edu    Param<int> phase;
5852623SN/A
5862623SN/A    Param<bool> defer_registration;
5872623SN/A    Param<int> width;
5882623SN/A    Param<bool> function_trace;
5892623SN/A    Param<Tick> function_trace_start;
5902623SN/A    Param<bool> simulate_stalls;
5912623SN/A
5922623SN/AEND_DECLARE_SIM_OBJECT_PARAMS(AtomicSimpleCPU)
5932623SN/A
5942623SN/ABEGIN_INIT_SIM_OBJECT_PARAMS(AtomicSimpleCPU)
5952623SN/A
5962623SN/A    INIT_PARAM(max_insts_any_thread,
5972623SN/A               "terminate when any thread reaches this inst count"),
5982623SN/A    INIT_PARAM(max_insts_all_threads,
5992623SN/A               "terminate when all threads have reached this inst count"),
6002623SN/A    INIT_PARAM(max_loads_any_thread,
6012623SN/A               "terminate when any thread reaches this load count"),
6022623SN/A    INIT_PARAM(max_loads_all_threads,
6032623SN/A               "terminate when all threads have reached this load count"),
6043119Sktlim@umich.edu    INIT_PARAM(progress_interval, "Progress interval"),
6052901Ssaidi@eecs.umich.edu    INIT_PARAM(system, "system object"),
6063170Sstever@eecs.umich.edu    INIT_PARAM(cpu_id, "processor ID"),
6072623SN/A
6082623SN/A#if FULL_SYSTEM
6092623SN/A    INIT_PARAM(itb, "Instruction TLB"),
6102623SN/A    INIT_PARAM(dtb, "Data TLB"),
6112623SN/A    INIT_PARAM(profile, ""),
6123617Sbinkertn@umich.edu    INIT_PARAM(do_quiesce, ""),
6133617Sbinkertn@umich.edu    INIT_PARAM(do_checkpoint_insts, ""),
6143617Sbinkertn@umich.edu    INIT_PARAM(do_statistics_insts, ""),
6152623SN/A#else
6162623SN/A    INIT_PARAM(workload, "processes to run"),
6172623SN/A#endif // FULL_SYSTEM
6182623SN/A
6192623SN/A    INIT_PARAM(clock, "clock speed"),
6203661Srdreslin@umich.edu    INIT_PARAM_DFLT(phase, "clock phase", 0),
6212623SN/A    INIT_PARAM(defer_registration, "defer system registration (for sampling)"),
6222623SN/A    INIT_PARAM(width, "cpu width"),
6232623SN/A    INIT_PARAM(function_trace, "Enable function trace"),
6242623SN/A    INIT_PARAM(function_trace_start, "Cycle to start function trace"),
6252623SN/A    INIT_PARAM(simulate_stalls, "Simulate cache stall cycles")
6262623SN/A
6272623SN/AEND_INIT_SIM_OBJECT_PARAMS(AtomicSimpleCPU)
6282623SN/A
6292623SN/A
6302623SN/ACREATE_SIM_OBJECT(AtomicSimpleCPU)
6312623SN/A{
6322623SN/A    AtomicSimpleCPU::Params *params = new AtomicSimpleCPU::Params();
6332623SN/A    params->name = getInstanceName();
6342623SN/A    params->numberOfThreads = 1;
6352623SN/A    params->max_insts_any_thread = max_insts_any_thread;
6362623SN/A    params->max_insts_all_threads = max_insts_all_threads;
6372623SN/A    params->max_loads_any_thread = max_loads_any_thread;
6382623SN/A    params->max_loads_all_threads = max_loads_all_threads;
6393119Sktlim@umich.edu    params->progress_interval = progress_interval;
6402623SN/A    params->deferRegistration = defer_registration;
6413661Srdreslin@umich.edu    params->phase = phase;
6422623SN/A    params->clock = clock;
6432623SN/A    params->functionTrace = function_trace;
6442623SN/A    params->functionTraceStart = function_trace_start;
6452623SN/A    params->width = width;
6462623SN/A    params->simulate_stalls = simulate_stalls;
6472901Ssaidi@eecs.umich.edu    params->system = system;
6483170Sstever@eecs.umich.edu    params->cpu_id = cpu_id;
6492623SN/A
6502623SN/A#if FULL_SYSTEM
6512623SN/A    params->itb = itb;
6522623SN/A    params->dtb = dtb;
6532623SN/A    params->profile = profile;
6543617Sbinkertn@umich.edu    params->do_quiesce = do_quiesce;
6553617Sbinkertn@umich.edu    params->do_checkpoint_insts = do_checkpoint_insts;
6563617Sbinkertn@umich.edu    params->do_statistics_insts = do_statistics_insts;
6572623SN/A#else
6582623SN/A    params->process = workload;
6592623SN/A#endif
6602623SN/A
6612623SN/A    AtomicSimpleCPU *cpu = new AtomicSimpleCPU(params);
6622623SN/A    return cpu;
6632623SN/A}
6642623SN/A
6652623SN/AREGISTER_SIM_OBJECT("AtomicSimpleCPU", AtomicSimpleCPU)
6662623SN/A
667