mem-cache: Avoid hiding a virtual method in the dictionary compressor.

[gem5.git] / src / mem / port.cc

diff --git a/src/mem/port.cc b/src/mem/port.cc
index bbc98c160c578e185a4c520dfed57e2cc84322bd..36e11caec8c9f7c87ecc9abbc260171b7d555a4b 100644 (file)
--- a/src/mem/port.cc
+++ b/src/mem/port.cc
@@ -1,4 +1,16 @@
 /*
+ * Copyright (c) 2012,2015,2017 ARM Limited
+ * All rights reserved
+ *
+ * The license below extends only to copyright in the software and shall
+ * not be construed as granting a license to any other intellectual
+ * property including but not limited to intellectual property relating
+ * to a hardware implementation of the functionality of the software
+ * licensed hereunder.  You may use the software subject to the license
+ * terms below provided that you ensure that this notice is replicated
+ * unmodified and in its entirety in all distributions of the software,
+ * modified or unmodified, in source code or in binary form.
+ *
  * Copyright (c) 2002-2005 The Regents of The University of Michigan
  * All rights reserved.
  *
@@ -26,60 +38,109 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * Authors: Steve Reinhardt
+ *          Andreas Hansson
+ *          William Wang
  */
 
 /**
  * @file
  * Port object definitions.
  */
+#include "mem/port.hh"
 
-#include "base/chunk_generator.hh"
 #include "base/trace.hh"
-#include "mem/port.hh"
+#include "sim/sim_object.hh"
 
-void
-Port::setPeer(Port *port)
+/**
+ * Master port
+ */
+MasterPort::MasterPort(const std::string& name, SimObject* _owner, PortID _id)
+    : Port(name, _id), _slavePort(NULL), owner(*_owner)
 {
-    DPRINTF(Config, "setting peer to %s\n", port->name());
-    peer = port;
 }
 
-void
-Port::blobHelper(Addr addr, uint8_t *p, int size, Packet::Command cmd)
+MasterPort::~MasterPort()
 {
-    Request req;
-    Packet pkt(&req, cmd, Packet::Broadcast);
+}
 
-    for (ChunkGenerator gen(addr, size, peerBlockSize());
-         !gen.done(); gen.next()) {
-        req.setPhys(gen.addr(), gen.size(), 0);
-        pkt.reinitFromRequest();
-        pkt.dataStatic(p);
-        sendFunctional(&pkt);
-        p += gen.size();
+void
+MasterPort::bind(Port &peer)
+{
+    auto *slave_port = dynamic_cast<SlavePort *>(&peer);
+    if (!slave_port) {
+        fatal("Attempt to bind port %s to non-slave port %s.",
+                name(), peer.name());
     }
+    // master port keeps track of the slave port
+    _slavePort = slave_port;
+    Port::bind(peer);
+    // slave port also keeps track of master port
+    _slavePort->slaveBind(*this);
 }
 
 void
-Port::writeBlob(Addr addr, uint8_t *p, int size)
+MasterPort::unbind()
 {
-    blobHelper(addr, p, size, Packet::WriteReq);
+    if (_slavePort == NULL)
+        panic("Attempting to unbind master port %s that is not connected\n",
+              name());
+    _slavePort->slaveUnbind();
+    _slavePort = nullptr;
+    Port::unbind();
+}
+
+AddrRangeList
+MasterPort::getAddrRanges() const
+{
+    return _slavePort->getAddrRanges();
 }
 
 void
-Port::readBlob(Addr addr, uint8_t *p, int size)
+MasterPort::printAddr(Addr a)
+{
+    auto req = std::make_shared<Request>(
+        a, 1, 0, Request::funcMasterId);
+
+    Packet pkt(req, MemCmd::PrintReq);
+    Packet::PrintReqState prs(std::cerr);
+    pkt.senderState = &prs;
+
+    sendFunctional(&pkt);
+}
+
+/**
+ * Slave port
+ */
+SlavePort::SlavePort(const std::string& name, SimObject* _owner, PortID id)
+    : Port(name, id), _masterPort(NULL), defaultBackdoorWarned(false),
+    owner(*_owner)
+{
+}
+
+SlavePort::~SlavePort()
 {
-    blobHelper(addr, p, size, Packet::ReadReq);
 }
 
 void
-Port::memsetBlob(Addr addr, uint8_t val, int size)
+SlavePort::slaveUnbind()
 {
-    // quick and dirty...
-    uint8_t *buf = new uint8_t[size];
+    _masterPort = NULL;
+    Port::unbind();
+}
 
-    memset(buf, val, size);
-    blobHelper(addr, buf, size, Packet::WriteReq);
+void
+SlavePort::slaveBind(MasterPort& master_port)
+{
+    _masterPort = &master_port;
+    Port::bind(master_port);
+}
 
-    delete [] buf;
+Tick
+SlavePort::recvAtomicBackdoor(PacketPtr pkt, MemBackdoorPtr &backdoor)
+{
+    if (!defaultBackdoorWarned) {
+        warn("Port %s doesn't support requesting a back door.", name());
+        defaultBackdoorWarned = true;
+    }
+    return recvAtomic(pkt);
 }