From d7b3020324782bd0382ff800fb27b165cd3c65e3 Mon Sep 17 00:00:00 2001 From: Gabe Black Date: Sat, 1 Oct 2022 03:18:20 -0700 Subject: [PATCH] dev,mem,systemc: Implement and use the recvMemBackdoorReq func. Change-Id: If6e12d4fcef0c31131a9768099a72542a8f62ab1 Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/65753 Tested-by: kokoro Reviewed-by: Jason Lowe-Power Maintainer: Gabe Black Reviewed-by: Jui-min Lee --- src/mem/cfi_mem.cc | 15 ++++++++++++ src/mem/cfi_mem.hh | 4 +++ src/mem/coherent_xbar.cc | 8 ++++++ src/mem/coherent_xbar.hh | 12 +++++++++ src/mem/mem_ctrl.cc | 18 ++++++++++++++ src/mem/mem_ctrl.hh | 4 +++ src/mem/noncoherent_xbar.cc | 8 ++++++ src/mem/noncoherent_xbar.hh | 9 +++++++ src/mem/simple_mem.cc | 14 +++++++++++ src/mem/simple_mem.hh | 4 +++ src/mem/sys_bridge.hh | 7 ++++++ src/systemc/tlm_bridge/gem5_to_tlm.cc | 25 +++++++++++++++++++ src/systemc/tlm_bridge/gem5_to_tlm.hh | 9 +++++++ src/systemc/tlm_bridge/tlm_to_gem5.cc | 35 +++++++++++++++------------ 14 files changed, 156 insertions(+), 16 deletions(-) diff --git a/src/mem/cfi_mem.cc b/src/mem/cfi_mem.cc index 70dc43fca8..f8c1084700 100644 --- a/src/mem/cfi_mem.cc +++ b/src/mem/cfi_mem.cc @@ -275,6 +275,14 @@ CfiMemory::recvFunctional(PacketPtr pkt) pkt->popLabel(); } +void +CfiMemory::recvMemBackdoorReq(const MemBackdoorReq &req, + MemBackdoorPtr &_backdoor) +{ + if (backdoor.ptr()) + _backdoor = &backdoor; +} + bool CfiMemory::recvTimingReq(PacketPtr pkt) { @@ -486,6 +494,13 @@ CfiMemory::MemoryPort::recvFunctional(PacketPtr pkt) mem.recvFunctional(pkt); } +void +CfiMemory::MemoryPort::recvMemBackdoorReq(const MemBackdoorReq &req, + MemBackdoorPtr &_backdoor) +{ + mem.recvMemBackdoorReq(req, _backdoor); +} + bool CfiMemory::MemoryPort::recvTimingReq(PacketPtr pkt) { diff --git a/src/mem/cfi_mem.hh b/src/mem/cfi_mem.hh index 5a7a1c57aa..4a0226736a 100644 --- a/src/mem/cfi_mem.hh +++ b/src/mem/cfi_mem.hh @@ -248,6 +248,8 @@ class CfiMemory : public AbstractMemory Tick recvAtomicBackdoor( PacketPtr pkt, MemBackdoorPtr &_backdoor) override; void recvFunctional(PacketPtr pkt) override; + void recvMemBackdoorReq(const MemBackdoorReq &req, + MemBackdoorPtr &_backdoor) override; bool recvTimingReq(PacketPtr pkt) override; void recvRespRetry() override; AddrRangeList getAddrRanges() const override; @@ -361,6 +363,8 @@ class CfiMemory : public AbstractMemory Tick recvAtomic(PacketPtr pkt); Tick recvAtomicBackdoor(PacketPtr pkt, MemBackdoorPtr &_backdoor); void recvFunctional(PacketPtr pkt); + void recvMemBackdoorReq(const MemBackdoorReq &req, + MemBackdoorPtr &_backdoor); bool recvTimingReq(PacketPtr pkt); void recvRespRetry(); diff --git a/src/mem/coherent_xbar.cc b/src/mem/coherent_xbar.cc index 7d1cd5d57d..8163299a09 100644 --- a/src/mem/coherent_xbar.cc +++ b/src/mem/coherent_xbar.cc @@ -997,6 +997,14 @@ CoherentXBar::forwardAtomic(PacketPtr pkt, PortID exclude_cpu_side_port_id, return std::make_pair(snoop_response_cmd, snoop_response_latency); } +void +CoherentXBar::recvMemBackdoorReq(const MemBackdoorReq &req, + MemBackdoorPtr &backdoor) +{ + PortID dest_id = findPort(req.range()); + memSidePorts[dest_id]->sendMemBackdoorReq(req, backdoor); +} + void CoherentXBar::recvFunctional(PacketPtr pkt, PortID cpu_side_port_id) { diff --git a/src/mem/coherent_xbar.hh b/src/mem/coherent_xbar.hh index 1c55cc00c8..9693d9225e 100644 --- a/src/mem/coherent_xbar.hh +++ b/src/mem/coherent_xbar.hh @@ -136,6 +136,13 @@ class CoherentXBar : public BaseXBar xbar.recvFunctional(pkt, id); } + void + recvMemBackdoorReq(const MemBackdoorReq &req, + MemBackdoorPtr &backdoor) override + { + xbar.recvMemBackdoorReq(req, backdoor); + } + AddrRangeList getAddrRanges() const override { @@ -374,6 +381,11 @@ class CoherentXBar : public BaseXBar transaction.*/ void recvFunctional(PacketPtr pkt, PortID cpu_side_port_id); + /** Function called by the port when the crossbar receives a request for + a memory backdoor.*/ + void recvMemBackdoorReq(const MemBackdoorReq &req, + MemBackdoorPtr &backdoor); + /** Function called by the port when the crossbar is receiving a functional snoop transaction.*/ void recvFunctionalSnoop(PacketPtr pkt, PortID mem_side_port_id); diff --git a/src/mem/mem_ctrl.cc b/src/mem/mem_ctrl.cc index c65d68a5a7..beaace1cbf 100644 --- a/src/mem/mem_ctrl.cc +++ b/src/mem/mem_ctrl.cc @@ -1364,6 +1364,17 @@ MemCtrl::recvFunctional(PacketPtr pkt) pkt->print()); } +void +MemCtrl::recvMemBackdoorReq(const MemBackdoorReq &req, + MemBackdoorPtr &backdoor) +{ + panic_if(!dram->getAddrRange().contains(req.range().start()), + "Can't handle address range for backdoor %s.", + req.range().to_string()); + + dram->getBackdoor(backdoor); +} + bool MemCtrl::recvFunctionalLogic(PacketPtr pkt, MemInterface* mem_intr) { @@ -1474,6 +1485,13 @@ MemCtrl::MemoryPort::recvFunctional(PacketPtr pkt) pkt->popLabel(); } +void +MemCtrl::MemoryPort::recvMemBackdoorReq(const MemBackdoorReq &req, + MemBackdoorPtr &backdoor) +{ + ctrl.recvMemBackdoorReq(req, backdoor); +} + Tick MemCtrl::MemoryPort::recvAtomic(PacketPtr pkt) { diff --git a/src/mem/mem_ctrl.hh b/src/mem/mem_ctrl.hh index fe5d478280..2819fb4caa 100644 --- a/src/mem/mem_ctrl.hh +++ b/src/mem/mem_ctrl.hh @@ -267,6 +267,8 @@ class MemCtrl : public qos::MemCtrl PacketPtr pkt, MemBackdoorPtr &backdoor) override; void recvFunctional(PacketPtr pkt) override; + void recvMemBackdoorReq(const MemBackdoorReq &req, + MemBackdoorPtr &backdoor) override; bool recvTimingReq(PacketPtr) override; @@ -784,6 +786,8 @@ class MemCtrl : public qos::MemCtrl virtual Tick recvAtomic(PacketPtr pkt); virtual Tick recvAtomicBackdoor(PacketPtr pkt, MemBackdoorPtr &backdoor); virtual void recvFunctional(PacketPtr pkt); + virtual void recvMemBackdoorReq(const MemBackdoorReq &req, + MemBackdoorPtr &backdoor); virtual bool recvTimingReq(PacketPtr pkt); bool recvFunctionalLogic(PacketPtr pkt, MemInterface* mem_intr); diff --git a/src/mem/noncoherent_xbar.cc b/src/mem/noncoherent_xbar.cc index 67efdba84a..0a378e2c63 100644 --- a/src/mem/noncoherent_xbar.cc +++ b/src/mem/noncoherent_xbar.cc @@ -284,6 +284,14 @@ NoncoherentXBar::recvAtomicBackdoor(PacketPtr pkt, PortID cpu_side_port_id, return response_latency; } +void +NoncoherentXBar::recvMemBackdoorReq(const MemBackdoorReq &req, + MemBackdoorPtr &backdoor) +{ + PortID dest_id = findPort(req.range()); + memSidePorts[dest_id]->sendMemBackdoorReq(req, backdoor); +} + void NoncoherentXBar::recvFunctional(PacketPtr pkt, PortID cpu_side_port_id) { diff --git a/src/mem/noncoherent_xbar.hh b/src/mem/noncoherent_xbar.hh index ab833148b5..03f751b77d 100644 --- a/src/mem/noncoherent_xbar.hh +++ b/src/mem/noncoherent_xbar.hh @@ -126,6 +126,13 @@ class NoncoherentXBar : public BaseXBar xbar.recvFunctional(pkt, id); } + void + recvMemBackdoorReq(const MemBackdoorReq &req, + MemBackdoorPtr &backdoor) override + { + xbar.recvMemBackdoorReq(req, backdoor); + } + AddrRangeList getAddrRanges() const override { @@ -179,6 +186,8 @@ class NoncoherentXBar : public BaseXBar Tick recvAtomicBackdoor(PacketPtr pkt, PortID cpu_side_port_id, MemBackdoorPtr *backdoor=nullptr); void recvFunctional(PacketPtr pkt, PortID cpu_side_port_id); + void recvMemBackdoorReq(const MemBackdoorReq &req, + MemBackdoorPtr &backdoor); public: diff --git a/src/mem/simple_mem.cc b/src/mem/simple_mem.cc index ced3a38cf4..27fcac1183 100644 --- a/src/mem/simple_mem.cc +++ b/src/mem/simple_mem.cc @@ -108,6 +108,13 @@ SimpleMemory::recvFunctional(PacketPtr pkt) pkt->popLabel(); } +void +SimpleMemory::recvMemBackdoorReq(const MemBackdoorReq &req, + MemBackdoorPtr &_backdoor) +{ + getBackdoor(_backdoor); +} + bool SimpleMemory::recvTimingReq(PacketPtr pkt) { @@ -294,6 +301,13 @@ SimpleMemory::MemoryPort::recvFunctional(PacketPtr pkt) mem.recvFunctional(pkt); } +void +SimpleMemory::MemoryPort::recvMemBackdoorReq(const MemBackdoorReq &req, + MemBackdoorPtr &backdoor) +{ + mem.recvMemBackdoorReq(req, backdoor); +} + bool SimpleMemory::MemoryPort::recvTimingReq(PacketPtr pkt) { diff --git a/src/mem/simple_mem.hh b/src/mem/simple_mem.hh index fc6d6849d5..75a03fbe0e 100644 --- a/src/mem/simple_mem.hh +++ b/src/mem/simple_mem.hh @@ -98,6 +98,8 @@ class SimpleMemory : public AbstractMemory Tick recvAtomicBackdoor( PacketPtr pkt, MemBackdoorPtr &_backdoor) override; void recvFunctional(PacketPtr pkt) override; + void recvMemBackdoorReq(const MemBackdoorReq &req, + MemBackdoorPtr &backdoor) override; bool recvTimingReq(PacketPtr pkt) override; void recvRespRetry() override; AddrRangeList getAddrRanges() const override; @@ -191,6 +193,8 @@ class SimpleMemory : public AbstractMemory Tick recvAtomic(PacketPtr pkt); Tick recvAtomicBackdoor(PacketPtr pkt, MemBackdoorPtr &_backdoor); void recvFunctional(PacketPtr pkt); + void recvMemBackdoorReq(const MemBackdoorReq &req, + MemBackdoorPtr &backdoor); bool recvTimingReq(PacketPtr pkt); void recvRespRetry(); }; diff --git a/src/mem/sys_bridge.hh b/src/mem/sys_bridge.hh index 8fa3131f25..15a3fc8270 100644 --- a/src/mem/sys_bridge.hh +++ b/src/mem/sys_bridge.hh @@ -331,6 +331,13 @@ class SysBridge : public SimObject pkt->requestorId()); } + void + recvMemBackdoorReq(const MemBackdoorReq &req, + MemBackdoorPtr &backdoor) override + { + targetPort->sendMemBackdoorReq(req, backdoor); + } + AddrRangeList getAddrRanges() const override { diff --git a/src/systemc/tlm_bridge/gem5_to_tlm.cc b/src/systemc/tlm_bridge/gem5_to_tlm.cc index 10f7d1a9c7..a5eb9df27e 100644 --- a/src/systemc/tlm_bridge/gem5_to_tlm.cc +++ b/src/systemc/tlm_bridge/gem5_to_tlm.cc @@ -509,6 +509,31 @@ Gem5ToTlmBridge::recvFunctional(PacketPtr packet) trans->release(); } +template +void +Gem5ToTlmBridge::recvMemBackdoorReq(const MemBackdoorReq &req, + MemBackdoorPtr &backdoor) +{ + // Create a transaction to send along to TLM's get_direct_mem_ptr. + tlm::tlm_generic_payload *trans = mm.allocate(); + trans->acquire(); + trans->set_address(req.range().start()); + trans->set_data_length(req.range().size()); + trans->set_streaming_width(req.range().size()); + trans->set_data_ptr(nullptr); + + if (req.writeable()) + trans->set_command(tlm::TLM_WRITE_COMMAND); + else if (req.readable()) + trans->set_command(tlm::TLM_READ_COMMAND); + else + trans->set_command(tlm::TLM_IGNORE_COMMAND); + + backdoor = getBackdoor(*trans); + + trans->release(); +} + template tlm::tlm_sync_enum Gem5ToTlmBridge::nb_transport_bw(tlm::tlm_generic_payload &trans, diff --git a/src/systemc/tlm_bridge/gem5_to_tlm.hh b/src/systemc/tlm_bridge/gem5_to_tlm.hh index 0cb925ee55..23415b843b 100644 --- a/src/systemc/tlm_bridge/gem5_to_tlm.hh +++ b/src/systemc/tlm_bridge/gem5_to_tlm.hh @@ -62,6 +62,7 @@ #include #include +#include "mem/backdoor.hh" #include "mem/port.hh" #include "params/Gem5ToTlmBridgeBase.hh" #include "sim/system.hh" @@ -117,6 +118,12 @@ class Gem5ToTlmBridge : public Gem5ToTlmBridgeBase { return bridge.recvFunctional(pkt); } + void + recvMemBackdoorReq(const gem5::MemBackdoorReq &req, + gem5::MemBackdoorPtr &backdoor) override + { + bridge.recvMemBackdoorReq(req, backdoor); + } bool recvTimingReq(gem5::PacketPtr pkt) override { @@ -179,6 +186,8 @@ class Gem5ToTlmBridge : public Gem5ToTlmBridgeBase gem5::Tick recvAtomicBackdoor(gem5::PacketPtr pkt, gem5::MemBackdoorPtr &backdoor); void recvFunctional(gem5::PacketPtr packet); + void recvMemBackdoorReq(const gem5::MemBackdoorReq &req, + gem5::MemBackdoorPtr &backdoor); bool recvTimingReq(gem5::PacketPtr packet); bool tryTiming(gem5::PacketPtr packet); bool recvTimingSnoopResp(gem5::PacketPtr packet); diff --git a/src/systemc/tlm_bridge/tlm_to_gem5.cc b/src/systemc/tlm_bridge/tlm_to_gem5.cc index 703e118dee..468ea83f37 100644 --- a/src/systemc/tlm_bridge/tlm_to_gem5.cc +++ b/src/systemc/tlm_bridge/tlm_to_gem5.cc @@ -401,13 +401,26 @@ bool TlmToGem5Bridge::get_direct_mem_ptr(tlm::tlm_generic_payload &trans, tlm::tlm_dmi &dmi_data) { - auto [pkt, pkt_created] = payload2packet(_id, trans); - pkt->pushSenderState(new Gem5SystemC::TlmSenderState(trans)); - if (pkt_created) - pkt->req->setFlags(Request::NO_ACCESS); + MemBackdoor::Flags flags; + switch (trans.get_command()) { + case tlm::TLM_READ_COMMAND: + flags = MemBackdoor::Readable; + break; + case tlm::TLM_WRITE_COMMAND: + flags = MemBackdoor::Writeable; + break; + default: + panic("TlmToGem5Bridge: " + "received transaction with unsupported command"); + } + Addr start_addr = trans.get_address(); + Addr length = trans.get_data_length(); + MemBackdoorReq req({start_addr, start_addr + length}, flags); MemBackdoorPtr backdoor = nullptr; - bmp.sendAtomicBackdoor(pkt, backdoor); + + bmp.sendMemBackdoorReq(req, backdoor); + if (backdoor) { trans.set_dmi_allowed(true); dmi_data.set_dmi_ptr(backdoor->ptr()); @@ -434,17 +447,7 @@ TlmToGem5Bridge::get_direct_mem_ptr(tlm::tlm_generic_payload &trans, } } - gem5::Packet::SenderState *senderState = pkt->popSenderState(); - sc_assert( - nullptr != dynamic_cast(senderState)); - - // clean up - delete senderState; - - setPayloadResponse(trans, pkt); - - if (pkt_created) - destroyPacket(pkt); + trans.set_response_status(tlm::TLM_OK_RESPONSE); return backdoor != nullptr; }