#include <list>
-#include "base/range.hh"
+#include "base/addr_range.hh"
#include "mem/packet.hh"
/**
* defined.
*/
-typedef std::list<Range<Addr> > AddrRangeList;
-typedef std::list<Range<Addr> >::iterator AddrRangeIter;
+typedef std::list<AddrRange> AddrRangeList;
+typedef std::list<AddrRange>::iterator AddrRangeIter;
+typedef std::list<AddrRange>::const_iterator AddrRangeConstIter;
class MemObject;
/**
* Ports are used to interface memory objects to each other. A port is
* either a master or a slave and the connected peer is always of the
- * opposite role.
- *
- * Each port has a name and an owner, and enables three basic types of
- * accesses to the peer port: functional, atomic and timing.
+ * opposite role. Each port has a name, an owner, and an identifier.
*/
class Port
{
*/
const PortID id;
- /** A pointer to the peer port. */
- Port* peer;
-
/** A reference to the MemObject that owns this port. */
MemObject& owner;
/** Get the port id. */
PortID getId() const { return id; }
+};
+
+/** Forward declaration */
+class BaseSlavePort;
+
+/**
+ * A BaseMasterPort is a protocol-agnostic master port, responsible
+ * only for the structural connection to a slave port. The final
+ * master port that inherits from the base class must override the
+ * bind member function for the specific slave port class.
+ */
+class BaseMasterPort : public Port
+{
+
protected:
- /**
- * Called by a peer port if sendTimingReq, sendTimingResp or
- * sendTimingSnoopResp was unsuccesful, and had to wait.
- */
- virtual void recvRetry() = 0;
+ BaseSlavePort* _baseSlavePort;
+
+ BaseMasterPort(const std::string& name, MemObject* owner,
+ PortID id = InvalidPortID);
+ virtual ~BaseMasterPort();
public:
- /**
- * Send a retry to a peer port that previously attempted a
- * sendTimingReq, sendTimingResp or sendTimingSnoopResp which was
- * unsuccessful.
- */
- void sendRetry() { return peer->recvRetry(); }
+ virtual void bind(BaseSlavePort& slave_port) = 0;
+ virtual void unbind() = 0;
+ BaseSlavePort& getSlavePort() const;
+ bool isConnected() const;
+
+};
+
+/**
+ * A BaseSlavePort is a protocol-agnostic slave port, responsible
+ * only for the structural connection to a master port.
+ */
+class BaseSlavePort : public Port
+{
+
+ protected:
+
+ BaseMasterPort* _baseMasterPort;
+
+ BaseSlavePort(const std::string& name, MemObject* owner,
+ PortID id = InvalidPortID);
+ virtual ~BaseSlavePort();
+
+ public:
+
+ BaseMasterPort& getMasterPort() const;
+ bool isConnected() const;
};
class SlavePort;
/**
- * A MasterPort is a specialisation of a port. In addition to the
- * basic functionality of sending packets to its slave peer, it also
- * has functions specific to a master, e.g. to receive range changes
- * or determine if the port is snooping or not.
+ * A MasterPort is a specialisation of a BaseMasterPort, 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
+ * determine if the port is snooping or not.
*/
-class MasterPort : public Port
+class MasterPort : public BaseMasterPort
{
friend class SlavePort;
PortID id = InvalidPortID);
virtual ~MasterPort();
- void bind(SlavePort& slave_port);
- SlavePort& getSlavePort() const;
- bool isConnected() const;
+ /**
+ * Bind this master port to a slave port. This also does the
+ * mirror action and binds the slave port to the master port.
+ */
+ void bind(BaseSlavePort& slave_port);
+
+ /**
+ * Unbind this master port and the associated slave port.
+ */
+ void unbind();
/**
* Send an atomic request packet, where the data is moved and the
*/
bool sendTimingSnoopResp(PacketPtr pkt);
+ /**
+ * Send a retry to the slave port that previously attempted a
+ * sendTimingResp to this master port and failed.
+ */
+ void sendRetry();
+
/**
* Determine if this master port is snooping or not. The default
* implementation returns false and thus tells the neighbour we
*/
unsigned peerBlockSize() const;
+ /**
+ * Get the address ranges of the connected slave port.
+ */
+ AddrRangeList getAddrRanges() const;
+
/** Inject a PrintReq for the given address to print the state of
* that address throughout the memory system. For debugging.
*/
panic("%s was not expecting a timing snoop request\n", name());
}
+ /**
+ * Called by the slave port if sendTimingReq or
+ * sendTimingSnoopResp was called on this master port (causing
+ * recvTimingReq and recvTimingSnoopResp to be called on the
+ * slave port) and was unsuccesful.
+ */
+ virtual void recvRetry() = 0;
+
/**
* Called to receive an address range change from the peer slave
- * port. the default implementation ignored the change and does
+ * 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 he laesddress ranges, e.g. in an
+ * needs to be aware of the address ranges, e.g. in an
* interconnect component like a bus.
*/
virtual void recvRangeChange() { }
* has functions specific to a slave, e.g. to send range changes
* and get the address ranges that the port responds to.
*/
-class SlavePort : public Port
+class SlavePort : public BaseSlavePort
{
friend class MasterPort;
PortID id = InvalidPortID);
virtual ~SlavePort();
- void bind(MasterPort& master_port);
- MasterPort& getMasterPort() const;
- bool isConnected() const;
-
/**
* Send an atomic snoop request packet, where the data is moved
* and the state is updated in zero time, without interleaving
*/
void sendTimingSnoopReq(PacketPtr pkt);
+ /**
+ * Send a retry to the master port that previously attempted a
+ * sendTimingReq or sendTimingSnoopResp to this slave port and
+ * failed.
+ */
+ void sendRetry();
+
/**
* Called by a peer port in order to determine the block size of
* the owner of this port.
*/
unsigned peerBlockSize() const;
+ /**
+ * Find out if the peer master port is snooping or not.
+ *
+ * @return true if the peer master port is snooping
+ */
+ bool isSnooping() const { return _masterPort->isSnooping(); }
+
/**
* Called by the owner to send a range change
*/
*
* @return a list of ranges responded to
*/
- virtual AddrRangeList getAddrRanges() = 0;
+ virtual AddrRangeList getAddrRanges() const = 0;
protected:
+ /**
+ * Called by the master port to unbind. Should never be called
+ * directly.
+ */
+ void unbind();
+
+ /**
+ * Called by the master port to bind. Should never be called
+ * directly.
+ */
+ void bind(MasterPort& master_port);
+
/**
* Receive an atomic request packet from the master port.
*/
panic("%s was not expecting a timing snoop response\n", name());
}
+ /**
+ * Called by the master port if sendTimingResp was called on this
+ * slave port (causing recvTimingResp to be called on the master
+ * port) and was unsuccesful.
+ */
+ virtual void recvRetry() = 0;
+
};
#endif //__MEM_PORT_HH__
projects / gem5.git / blobdiff