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 <noreply+kokoro@google.com>
Reviewed-by: Jason Lowe-Power <power.jg@gmail.com>
Maintainer: Gabe Black <gabeblack@google.com>
Reviewed-by: Jui-min Lee <fcrh@google.com>

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)
 {

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();
 

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)
 {

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);

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)
 {

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);

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)
 {

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:
 

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)
 {

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();
 };

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
         {

src/systemc/tlm_bridge/gem5_to_tlm.cc

@@ -509,6 +509,31 @@ Gem5ToTlmBridge<BITWIDTH>::recvFunctional(PacketPtr packet)
     trans->release();
 }
 
+template <unsigned int BITWIDTH>
+void
+Gem5ToTlmBridge<BITWIDTH>::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 <unsigned int BITWIDTH>
 tlm::tlm_sync_enum
 Gem5ToTlmBridge<BITWIDTH>::nb_transport_bw(tlm::tlm_generic_payload &trans,

src/systemc/tlm_bridge/gem5_to_tlm.hh

@@ -62,6 +62,7 @@
 #include <functional>
 #include <string>
 
+#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);

src/systemc/tlm_bridge/tlm_to_gem5.cc

@@ -401,13 +401,26 @@ bool
 TlmToGem5Bridge<BITWIDTH>::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<BITWIDTH>::get_direct_mem_ptr(tlm::tlm_generic_payload &trans,
         }
     }
 
-    gem5::Packet::SenderState *senderState = pkt->popSenderState();
-    sc_assert(
-        nullptr != dynamic_cast<Gem5SystemC::TlmSenderState*>(senderState));
-
-    // clean up
-    delete senderState;
-
-    setPayloadResponse(trans, pkt);
-
-    if (pkt_created)
-        destroyPacket(pkt);
+    trans.set_response_status(tlm::TLM_OK_RESPONSE);
 
     return backdoor != nullptr;
 }