Shivani Parekh has submitted this change. (
https://gem5-review.googlesource.com/c/public/gem5/+/32308 )
Change subject: mem: Deprecate SlavePort and MasterPort classes
......................................................................
mem: Deprecate SlavePort and MasterPort classes
After this change, if you use these classes or inherit from these
classes, the compiler will now give you a warning that these names are
deprecated. Instead, you should use ResponsePort and RequestPort,
respectively.
This patch simply deprecates these names. The following patches will
convert all of the code in gem5 to use these new names. The first step
is converting the class names and the uses of these classes, then we
will update the variable names to be more precise as well.
Change-Id: I5e6e90b2916df4dbfccdaabe97423f377a1f6e3f
Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/32308
Reviewed-by: Jason Lowe-Power <power...@gmail.com>
Maintainer: Jason Lowe-Power <power...@gmail.com>
Tested-by: kokoro <noreply+kok...@google.com>
---
M src/mem/port.cc
M src/mem/port.hh
2 files changed, 118 insertions(+), 97 deletions(-)
Approvals:
Jason Lowe-Power: Looks good to me, approved; Looks good to me, approved
kokoro: Regressions pass
diff --git a/src/mem/port.cc b/src/mem/port.cc
index 47e94f4..6460b59 100644
--- a/src/mem/port.cc
+++ b/src/mem/port.cc
@@ -50,7 +50,7 @@
namespace
{
-class DefaultMasterPort : public MasterPort
+class DefaultRequestPort : public RequestPort
{
protected:
[[noreturn]] void
@@ -60,7 +60,7 @@
}
public:
- DefaultMasterPort() : MasterPort("default_master_port", nullptr) {}
+ DefaultRequestPort() : RequestPort("default_request_port", nullptr) {}
// Atomic protocol.
Tick recvAtomicSnoop(PacketPtr) override { blowUp(); }
@@ -75,7 +75,7 @@
void recvFunctionalSnoop(PacketPtr) override { blowUp(); }
};
-class DefaultSlavePort : public SlavePort
+class DefaultResponsePort : public ResponsePort
{
protected:
[[noreturn]] void
@@ -85,7 +85,7 @@
}
public:
- DefaultSlavePort() : SlavePort("default_slave_port", nullptr) {}
+ DefaultResponsePort() : ResponsePort("default_response_port", nullptr)
{}
// Atomic protocol.
Tick recvAtomic(PacketPtr) override { blowUp(); }
@@ -103,54 +103,55 @@
AddrRangeList getAddrRanges() const override { return AddrRangeList();
}
};
-DefaultMasterPort defaultMasterPort;
-DefaultSlavePort defaultSlavePort;
+DefaultRequestPort defaultRequestPort;
+DefaultResponsePort defaultResponsePort;
} // anonymous namespace
/**
- * Master port
+ * Request port
*/
-MasterPort::MasterPort(const std::string& name, SimObject* _owner, PortID
_id)
- : Port(name, _id), _slavePort(&defaultSlavePort), owner(*_owner)
+RequestPort::RequestPort(const std::string& name, SimObject* _owner,
+ PortID _id) : Port(name, _id), _responsePort(&defaultResponsePort),
+ owner(*_owner)
{
}
-MasterPort::~MasterPort()
+RequestPort::~RequestPort()
{
}
void
-MasterPort::bind(Port &peer)
+RequestPort::bind(Port &peer)
{
- auto *slave_port = dynamic_cast<SlavePort *>(&peer);
- fatal_if(!slave_port, "Can't bind port %s to non-slave port %s.",
+ auto *response_port = dynamic_cast<ResponsePort *>(&peer);
+ fatal_if(!response_port, "Can't bind port %s to non-response port %s.",
name(), peer.name());
- // master port keeps track of the slave port
- _slavePort = slave_port;
+ // request port keeps track of the response port
+ _responsePort = response_port;
Port::bind(peer);
- // slave port also keeps track of master port
- _slavePort->slaveBind(*this);
+ // response port also keeps track of request port
+ _responsePort->slaveBind(*this);
}
void
-MasterPort::unbind()
+RequestPort::unbind()
{
- panic_if(!isConnected(), "Can't unbind master port %s which is not
bound.",
- name());
- _slavePort->slaveUnbind();
- _slavePort = &defaultSlavePort;
+ panic_if(!isConnected(), "Can't unbind request port %s which is "
+ "not bound.", name());
+ _responsePort->slaveUnbind();
+ _responsePort = &defaultResponsePort;
Port::unbind();
}
AddrRangeList
-MasterPort::getAddrRanges() const
+RequestPort::getAddrRanges() const
{
- return _slavePort->getAddrRanges();
+ return _responsePort->getAddrRanges();
}
void
-MasterPort::printAddr(Addr a)
+RequestPort::printAddr(Addr a)
{
auto req = std::make_shared<Request>(
a, 1, 0, Request::funcMasterId);
@@ -165,32 +166,32 @@
/**
* Slave port
*/
-SlavePort::SlavePort(const std::string& name, SimObject* _owner, PortID id)
- : Port(name, id), _masterPort(&defaultMasterPort),
+ResponsePort::ResponsePort(const std::string& name, SimObject* _owner,
+ PortID id) : Port(name, id), _requestPort(&defaultRequestPort),
defaultBackdoorWarned(false), owner(*_owner)
{
}
-SlavePort::~SlavePort()
+ResponsePort::~ResponsePort()
{
}
void
-SlavePort::slaveUnbind()
+ResponsePort::slaveUnbind()
{
- _masterPort = &defaultMasterPort;
+ _requestPort = &defaultRequestPort;
Port::unbind();
}
void
-SlavePort::slaveBind(MasterPort& master_port)
+ResponsePort::slaveBind(RequestPort& request_port)
{
- _masterPort = &master_port;
- Port::bind(master_port);
+ _requestPort = &request_port;
+ Port::bind(request_port);
}
Tick
-SlavePort::recvAtomicBackdoor(PacketPtr pkt, MemBackdoorPtr &backdoor)
+ResponsePort::recvAtomicBackdoor(PacketPtr pkt, MemBackdoorPtr &backdoor)
{
if (!defaultBackdoorWarned) {
warn("Port %s doesn't support requesting a back door.", name());
diff --git a/src/mem/port.hh b/src/mem/port.hh
index eadf7f4..f378f07 100644
--- a/src/mem/port.hh
+++ b/src/mem/port.hh
@@ -56,10 +56,13 @@
class SimObject;
/** Forward declaration */
+class MasterPort;
class SlavePort;
+class ResponsePort;
+
/**
- * A MasterPort is a specialisation of a BaseMasterPort, which
+ * A RequestPort is a specialisation of a Port, which
* implements the default protocol for the three different level of
* transport functions. In addition to the basic functionality of
* sending packets, it also has functions to receive range changes or
@@ -68,37 +71,37 @@
* The three protocols are atomic, timing, and functional, each with its
own
* header file.
*/
-class MasterPort : public Port, public AtomicRequestProtocol,
+class RequestPort: public Port, public AtomicRequestProtocol,
public TimingRequestProtocol, public FunctionalRequestProtocol
{
- friend class SlavePort;
+ friend class ResponsePort;
private:
- SlavePort *_slavePort;
+ ResponsePort *_responsePort;
protected:
SimObject &owner;
public:
- MasterPort(const std::string& name, SimObject* _owner,
+ RequestPort(const std::string& name, SimObject* _owner,
PortID id=InvalidPortID);
- virtual ~MasterPort();
+ virtual ~RequestPort();
/**
- * Bind this master port to a slave port. This also does the
- * mirror action and binds the slave port to the master port.
+ * Bind this request port to a response port. This also does the
+ * mirror action and binds the response port to the request port.
*/
void bind(Port &peer) override;
/**
- * Unbind this master port and the associated slave port.
+ * Unbind this request port and the associated response port.
*/
void unbind() override;
/**
- * Determine if this master port is snooping or not. The default
+ * Determine if this request port is snooping or not. The default
* implementation returns false and thus tells the neighbour we
- * are not snooping. Any master port that wants to receive snoop
+ * are not snooping. Any request port that wants to receive snoop
* requests (e.g. a cache connected to a bus) has to override this
* function.
*
@@ -107,7 +110,7 @@
virtual bool isSnooping() const { return false; }
/**
- * Get the address ranges of the connected slave port.
+ * Get the address ranges of the connected responder port.
*/
AddrRangeList getAddrRanges() const;
@@ -159,7 +162,7 @@
/* The timing protocol. */
/**
- * Attempt to send a timing request to the slave port by calling
+ * Attempt to send a timing request to the responder port by calling
* its corresponding receive function. If the send does not
* succeed, as indicated by the return value, then the sender must
* wait for a recvReqRetry at which point it can re-issue a
@@ -172,7 +175,7 @@
bool sendTimingReq(PacketPtr pkt);
/**
- * Check if the slave can handle a timing request.
+ * Check if the responder can handle a timing request.
*
* If the send cannot be handled at the moment, as indicated by
* the return value, then the sender will receive a recvReqRetry
@@ -180,12 +183,12 @@
*
* @param pkt Packet to send.
*
- * @return If the send was succesful or not.
+ * @return If the send was successful or not.
*/
bool tryTiming(PacketPtr pkt) const;
/**
- * Attempt to send a timing snoop response packet to the slave
+ * Attempt to send a timing snoop response packet to the response
* port by calling its corresponding receive function. If the send
* does not succeed, as indicated by the return value, then the
* sender must wait for a recvRetrySnoop at which point it can
@@ -196,8 +199,8 @@
bool sendTimingSnoopResp(PacketPtr pkt);
/**
- * Send a retry to the slave port that previously attempted a
- * sendTimingResp to this master port and failed. Note that this
+ * Send a retry to the response port that previously attempted a
+ * sendTimingResp to this request port and failed. Note that this
* is virtual so that the "fake" snoop response port in the
* coherent crossbar can override the behaviour.
*/
@@ -205,7 +208,7 @@
protected:
/**
- * Called to receive an address range change from the peer slave
+ * Called to receive an address range change from the peer response
* port. The default implementation ignores the change and does
* nothing. Override this function in a derived class if the owner
* needs to be aware of the address ranges, e.g. in an
@@ -242,22 +245,30 @@
}
};
+class M5_DEPRECATED MasterPort : public RequestPort
+{
+ public:
+ MasterPort(const std::string& name, SimObject* _owner,
+ PortID id=InvalidPortID) : RequestPort(name, _owner, id)
+ {}
+};
+
/**
- * A SlavePort is a specialisation of a port. In addition to the
- * basic functionality of sending packets to its master peer, it also
- * has functions specific to a slave, e.g. to send range changes
+ * A ResponsePort is a specialization of a port. In addition to the
+ * basic functionality of sending packets to its requestor peer, it also
+ * has functions specific to a responder, e.g. to send range changes
* and get the address ranges that the port responds to.
*
* The three protocols are atomic, timing, and functional, each with its
own
* header file.
*/
-class SlavePort : public Port, public AtomicResponseProtocol,
+class ResponsePort : public Port, public AtomicResponseProtocol,
public TimingResponseProtocol, public FunctionalResponseProtocol
{
- friend class MasterPort;
+ friend class RequestPort;
private:
- MasterPort* _masterPort;
+ RequestPort* _requestPort;
bool defaultBackdoorWarned;
@@ -265,25 +276,25 @@
SimObject& owner;
public:
- SlavePort(const std::string& name, SimObject* _owner,
+ ResponsePort(const std::string& name, SimObject* _owner,
PortID id=InvalidPortID);
- virtual ~SlavePort();
+ virtual ~ResponsePort();
/**
- * Find out if the peer master port is snooping or not.
+ * Find out if the peer request port is snooping or not.
*
- * @return true if the peer master port is snooping
+ * @return true if the peer request port is snooping
*/
- bool isSnooping() const { return _masterPort->isSnooping(); }
+ bool isSnooping() const { return _requestPort->isSnooping(); }
/**
* Called by the owner to send a range change
*/
- void sendRangeChange() const { _masterPort->recvRangeChange(); }
+ void sendRangeChange() const { _requestPort->recvRangeChange(); }
/**
* Get a list of the non-overlapping address ranges the owner is
- * responsible for. All slave ports must override this function
+ * responsible for. All response ports must override this function
* and return a populated list with at least one item.
*
* @return a list of ranges responded to
@@ -291,7 +302,7 @@
virtual AddrRangeList getAddrRanges() const = 0;
/**
- * We let the master port do the work, so these don't do anything.
+ * We let the request port do the work, so these don't do anything.
*/
void unbind() override {}
void bind(Port &peer) override {}
@@ -312,7 +323,7 @@
sendAtomicSnoop(PacketPtr pkt)
{
try {
- return AtomicResponseProtocol::sendSnoop(_masterPort, pkt);
+ return AtomicResponseProtocol::sendSnoop(_requestPort, pkt);
} catch (UnboundPortException) {
reportUnbound();
}
@@ -332,7 +343,7 @@
sendFunctionalSnoop(PacketPtr pkt) const
{
try {
- FunctionalResponseProtocol::sendSnoop(_masterPort, pkt);
+ FunctionalResponseProtocol::sendSnoop(_requestPort, pkt);
} catch (UnboundPortException) {
reportUnbound();
}
@@ -342,7 +353,7 @@
/* The timing protocol. */
/**
- * Attempt to send a timing response to the master port by calling
+ * Attempt to send a timing response to the request port by calling
* its corresponding receive function. If the send does not
* succeed, as indicated by the return value, then the sender must
* wait for a recvRespRetry at which point it can re-issue a
@@ -350,20 +361,20 @@
*
* @param pkt Packet to send.
*
- * @return If the send was succesful or not.
+ * @return If the send was successful or not.
*/
bool
sendTimingResp(PacketPtr pkt)
{
try {
- return TimingResponseProtocol::sendResp(_masterPort, pkt);
+ return TimingResponseProtocol::sendResp(_requestPort, pkt);
} catch (UnboundPortException) {
reportUnbound();
}
}
/**
- * Attempt to send a timing snoop request packet to the master port
+ * Attempt to send a timing snoop request packet to the request port
* by calling its corresponding receive function. Snoop requests
* always succeed and hence no return value is needed.
*
@@ -373,35 +384,35 @@
sendTimingSnoopReq(PacketPtr pkt)
{
try {
- TimingResponseProtocol::sendSnoopReq(_masterPort, pkt);
+ TimingResponseProtocol::sendSnoopReq(_requestPort, pkt);
} catch (UnboundPortException) {
reportUnbound();
}
}
/**
- * Send a retry to the master port that previously attempted a
- * sendTimingReq to this slave port and failed.
+ * Send a retry to the request port that previously attempted a
+ * sendTimingReq to this response port and failed.
*/
void
sendRetryReq()
{
try {
- TimingResponseProtocol::sendRetryReq(_masterPort);
+ TimingResponseProtocol::sendRetryReq(_requestPort);
} catch (UnboundPortException) {
reportUnbound();
}
}
/**
- * Send a retry to the master port that previously attempted a
- * sendTimingSnoopResp to this slave port and failed.
+ * Send a retry to the request port that previously attempted a
+ * sendTimingSnoopResp to this response port and failed.
*/
void
sendRetrySnoopResp()
{
try {
- TimingResponseProtocol::sendRetrySnoopResp(_masterPort);
+ TimingResponseProtocol::sendRetrySnoopResp(_requestPort);
} catch (UnboundPortException) {
reportUnbound();
}
@@ -409,16 +420,16 @@
protected:
/**
- * Called by the master port to unbind. Should never be called
+ * Called by the request port to unbind. Should never be called
* directly.
*/
void slaveUnbind();
/**
- * Called by the master port to bind. Should never be called
+ * Called by the request port to bind. Should never be called
* directly.
*/
- void slaveBind(MasterPort& master_port);
+ void slaveBind(RequestPort& request_port);
/**
* Default implementations.
@@ -438,71 +449,80 @@
}
};
+class M5_DEPRECATED SlavePort : public ResponsePort
+{
+ public:
+ SlavePort(const std::string& name, SimObject* _owner,
+ PortID id=InvalidPortID) : ResponsePort(name, _owner, id)
+ {}
+};
+
inline Tick
-MasterPort::sendAtomic(PacketPtr pkt)
+RequestPort::sendAtomic(PacketPtr pkt)
{
try {
- return AtomicRequestProtocol::send(_slavePort, pkt);
+ return AtomicRequestProtocol::send(_responsePort, pkt);
} catch (UnboundPortException) {
reportUnbound();
}
}
inline Tick
-MasterPort::sendAtomicBackdoor(PacketPtr pkt, MemBackdoorPtr &backdoor)
+RequestPort::sendAtomicBackdoor(PacketPtr pkt, MemBackdoorPtr &backdoor)
{
try {
- return AtomicRequestProtocol::sendBackdoor(_slavePort, pkt,
backdoor);
+ return AtomicRequestProtocol::sendBackdoor(_responsePort,
+ pkt, backdoor);
} catch (UnboundPortException) {
reportUnbound();
}
}
inline void
-MasterPort::sendFunctional(PacketPtr pkt) const
+RequestPort::sendFunctional(PacketPtr pkt) const
{
try {
- return FunctionalRequestProtocol::send(_slavePort, pkt);
+ return FunctionalRequestProtocol::send(_responsePort, pkt);
} catch (UnboundPortException) {
reportUnbound();
}
}
inline bool
-MasterPort::sendTimingReq(PacketPtr pkt)
+RequestPort::sendTimingReq(PacketPtr pkt)
{
try {
- return TimingRequestProtocol::sendReq(_slavePort, pkt);
+ return TimingRequestProtocol::sendReq(_responsePort, pkt);
} catch (UnboundPortException) {
reportUnbound();
}
}
inline bool
-MasterPort::tryTiming(PacketPtr pkt) const
+RequestPort::tryTiming(PacketPtr pkt) const
{
try {
- return TimingRequestProtocol::trySend(_slavePort, pkt);
+ return TimingRequestProtocol::trySend(_responsePort, pkt);
} catch (UnboundPortException) {
reportUnbound();
}
}
inline bool
-MasterPort::sendTimingSnoopResp(PacketPtr pkt)
+RequestPort::sendTimingSnoopResp(PacketPtr pkt)
{
try {
- return TimingRequestProtocol::sendSnoopResp(_slavePort, pkt);
+ return TimingRequestProtocol::sendSnoopResp(_responsePort, pkt);
} catch (UnboundPortException) {
reportUnbound();
}
}
inline void
-MasterPort::sendRetryResp()
+RequestPort::sendRetryResp()
{
try {
- TimingRequestProtocol::sendRetryResp(_slavePort);
+ TimingRequestProtocol::sendRetryResp(_responsePort);
} catch (UnboundPortException) {
reportUnbound();
}
--
To view, visit https://gem5-review.googlesource.com/c/public/gem5/+/32308
To unsubscribe, or for help writing mail filters, visit
https://gem5-review.googlesource.com/settings
Gerrit-Project: public/gem5
Gerrit-Branch: develop
Gerrit-Change-Id: I5e6e90b2916df4dbfccdaabe97423f377a1f6e3f
Gerrit-Change-Number: 32308
Gerrit-PatchSet: 5
Gerrit-Owner: Shivani Parekh <shpar...@ucdavis.edu>
Gerrit-Reviewer: Andreas Sandberg <andreas.sandb...@arm.com>
Gerrit-Reviewer: Bobby R. Bruce <bbr...@ucdavis.edu>
Gerrit-Reviewer: Gabe Black <gabebl...@google.com>
Gerrit-Reviewer: Giacomo Travaglini <giacomo.travagl...@arm.com>
Gerrit-Reviewer: Jason Lowe-Power <power...@gmail.com>
Gerrit-Reviewer: Matthew Poremba <matthew.pore...@amd.com>
Gerrit-Reviewer: Shivani Parekh <shpar...@ucdavis.edu>
Gerrit-Reviewer: kokoro <noreply+kok...@google.com>
Gerrit-CC: Nikos Nikoleris <nikos.nikole...@arm.com>
Gerrit-MessageType: merged
_______________________________________________
gem5-dev mailing list -- gem5-dev@gem5.org
To unsubscribe send an email to gem5-dev-le...@gem5.org
%(web_page_url)slistinfo%(cgiext)s/%(_internal_name)s
