Ruby Memory Vector: Allow more than 4GB of memory

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

diff --git a/src/mem/port.cc b/src/mem/port.cc
index 8edca16f74f4f8ae0612c860c6bb0271f5f85885..3827994fb93bba839b5d4be7145204af2ed6e9d6 100644 (file)
--- a/src/mem/port.cc
+++ b/src/mem/port.cc
@@ -1,4 +1,16 @@
 /*
+ * Copyright (c) 2012 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,6 +38,8 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * Authors: Steve Reinhardt
+ *          Andreas Hansson
+ *          William Wang
  */
 
 /**
@@ -33,12 +47,11 @@
  * Port object definitions.
  */
 #include "base/trace.hh"
-#include "debug/Config.hh"
 #include "mem/mem_object.hh"
 #include "mem/port.hh"
 
-Port::Port(const std::string &_name, MemObject *_owner)
-    : portName(_name), peer(NULL), owner(_owner)
+Port::Port(const std::string &_name, MemObject& _owner, PortID _id)
+    : portName(_name), id(_id), owner(_owner)
 {
 }
 
@@ -46,27 +59,183 @@ Port::~Port()
 {
 }
 
+/**
+ * Master port
+ */
+MasterPort::MasterPort(const std::string& name, MemObject* owner, PortID _id)
+    : Port(name, *owner, _id), _slavePort(NULL)
+{
+}
+
+MasterPort::~MasterPort()
+{
+}
+
+SlavePort&
+MasterPort::getSlavePort() const
+{
+    if(_slavePort == NULL)
+        panic("Cannot getSlavePort on master port %s that is not connected\n",
+              name());
+
+    return *_slavePort;
+}
+
+void
+MasterPort::unBind()
+{
+    _slavePort = NULL;
+}
+
+void
+MasterPort::bind(SlavePort& slave_port)
+{
+    // master port keeps track of the slave port
+    _slavePort = &slave_port;
+
+    // slave port also keeps track of master port
+    _slavePort->bind(*this);
+}
+
+bool
+MasterPort::isConnected() const
+{
+    return _slavePort != NULL;
+}
+
+unsigned
+MasterPort::peerBlockSize() const
+{
+    return _slavePort->deviceBlockSize();
+}
+
+AddrRangeList
+MasterPort::getAddrRanges() const
+{
+    return _slavePort->getAddrRanges();
+}
+
+Tick
+MasterPort::sendAtomic(PacketPtr pkt)
+{
+    assert(pkt->isRequest());
+    return _slavePort->recvAtomic(pkt);
+}
+
 void
-Port::setPeer(Port *port)
+MasterPort::sendFunctional(PacketPtr pkt)
+{
+    assert(pkt->isRequest());
+    return _slavePort->recvFunctional(pkt);
+}
+
+bool
+MasterPort::sendTimingReq(PacketPtr pkt)
 {
-    DPRINTF(Config, "setting peer to %s\n", port->name());
+    assert(pkt->isRequest());
+    return _slavePort->recvTimingReq(pkt);
+}
 
-    peer = port;
+bool
+MasterPort::sendTimingSnoopResp(PacketPtr pkt)
+{
+    assert(pkt->isResponse());
+    return _slavePort->recvTimingSnoopResp(pkt);
 }
 
 void
-Port::setOwner(MemObject *_owner)
+MasterPort::sendRetry()
 {
-    owner = _owner;
+    _slavePort->recvRetry();
 }
 
 void
-Port::printAddr(Addr a)
+MasterPort::printAddr(Addr a)
 {
     Request req(a, 1, 0, Request::funcMasterId);
-    Packet pkt(&req, MemCmd::PrintReq, Packet::Broadcast);
+    Packet pkt(&req, MemCmd::PrintReq);
     Packet::PrintReqState prs(std::cerr);
     pkt.senderState = &prs;
 
     sendFunctional(&pkt);
 }
+
+/**
+ * Slave port
+ */
+SlavePort::SlavePort(const std::string& name, MemObject* owner, PortID id)
+    : Port(name, *owner, id), _masterPort(NULL)
+{
+}
+
+SlavePort::~SlavePort()
+{
+}
+
+void
+SlavePort::unBind()
+{
+    _masterPort = NULL;
+}
+
+void
+SlavePort::bind(MasterPort& master_port)
+{
+    _masterPort = &master_port;
+}
+
+MasterPort&
+SlavePort::getMasterPort() const
+{
+    if (_masterPort == NULL)
+        panic("Cannot getMasterPort on slave port %s that is not connected\n",
+              name());
+
+    return *_masterPort;
+}
+
+unsigned
+SlavePort::peerBlockSize() const
+{
+    return _masterPort->deviceBlockSize();
+}
+
+bool
+SlavePort::isConnected() const
+{
+    return _masterPort != NULL;
+}
+
+Tick
+SlavePort::sendAtomicSnoop(PacketPtr pkt)
+{
+    assert(pkt->isRequest());
+    return _masterPort->recvAtomicSnoop(pkt);
+}
+
+void
+SlavePort::sendFunctionalSnoop(PacketPtr pkt)
+{
+    assert(pkt->isRequest());
+    return _masterPort->recvFunctionalSnoop(pkt);
+}
+
+bool
+SlavePort::sendTimingResp(PacketPtr pkt)
+{
+    assert(pkt->isResponse());
+    return _masterPort->recvTimingResp(pkt);
+}
+
+void
+SlavePort::sendTimingSnoopReq(PacketPtr pkt)
+{
+    assert(pkt->isRequest());
+    _masterPort->recvTimingSnoopReq(pkt);
+}
+
+void
+SlavePort::sendRetry()
+{
+    _masterPort->recvRetry();
+}