/*
- * Copyright (c) 2011-2015, 2018 ARM Limited
+ * Copyright (c) 2011-2015, 2018-2020 ARM Limited
* All rights reserved
*
* The license below extends only to copyright in the software and shall
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- * Authors: Ron Dreslinski
- * Ali Saidi
- * Andreas Hansson
- * William Wang
*/
/**
#include "base/addr_range_map.hh"
#include "base/types.hh"
-#include "mem/mem_object.hh"
#include "mem/qport.hh"
#include "params/BaseXBar.hh"
+#include "sim/clocked_object.hh"
#include "sim/stats.hh"
/**
* The BaseXBar is responsible for the basic flow control (busy or
* not), the administration of retries, and the address decoding.
*/
-class BaseXBar : public MemObject
+class BaseXBar : public ClockedObject
{
protected:
* PCIe, etc.
*
* The template parameter, PortClass, indicates the destination
- * port type for the layer. The retry list holds either master
- * ports or slave ports, depending on the direction of the
- * layer. Thus, a request layer has a retry list containing slave
- * ports, whereas a response layer holds master ports.
+ * port type for the layer. The retry list holds either memory-side ports
+ * or CPU-side ports, depending on the direction of the
+ * layer. Thus, a request layer has a retry list containing
+ * CPU-side ports, whereas a response layer holds memory-side ports.
*/
template <typename SrcType, typename DstType>
- class Layer : public Drainable
+ class Layer : public Drainable, public Stats::Group
{
public:
*/
DrainState drain() override;
- /**
- * Get the crossbar layer's name
- */
- const std::string name() const { return xbar.name() + _name; }
+ const std::string name() const { return _name; }
/**
*/
void failedTiming(SrcType* src_port, Tick busy_time);
- /** Occupy the layer until until */
void occupyLayer(Tick until);
/**
*/
void recvRetry();
- /**
- * Register stats for the layer
- */
- void regStats();
-
protected:
/**
* Sending the actual retry, in a manner specific to the
- * individual layers. Note that for a MasterPort, there is
+ * individual layers. Note that for a RequestPort, there is
* both a RequestLayer and a SnoopResponseLayer using the same
* port, but using different functions for the flow control.
*/
/** The crossbar this layer is a part of. */
BaseXBar& xbar;
- /** A name for this layer. */
std::string _name;
/**
*/
enum State { IDLE, BUSY, RETRY };
- /** track the state of the layer */
State state;
/**
* potential waiting port, or drain if asked to do so.
*/
void releaseLayer();
-
- /** event used to schedule a release of the layer */
EventFunctionWrapper releaseEvent;
/**
};
- class ReqLayer : public Layer<SlavePort,MasterPort>
+ class ReqLayer : public Layer<ResponsePort, RequestPort>
{
public:
/**
* @param _xbar the crossbar this layer belongs to
* @param _name the layer's name
*/
- ReqLayer(MasterPort& _port, BaseXBar& _xbar, const std::string& _name) :
- Layer(_port, _xbar, _name) {}
+ ReqLayer(RequestPort& _port, BaseXBar& _xbar,
+ const std::string& _name) :
+ Layer(_port, _xbar, _name)
+ {}
protected:
-
- void sendRetry(SlavePort* retry_port)
- { retry_port->sendRetryReq(); }
+ void
+ sendRetry(ResponsePort* retry_port) override
+ {
+ retry_port->sendRetryReq();
+ }
};
- class RespLayer : public Layer<MasterPort,SlavePort>
+ class RespLayer : public Layer<RequestPort, ResponsePort>
{
public:
/**
* @param _xbar the crossbar this layer belongs to
* @param _name the layer's name
*/
- RespLayer(SlavePort& _port, BaseXBar& _xbar, const std::string& _name) :
- Layer(_port, _xbar, _name) {}
+ RespLayer(ResponsePort& _port, BaseXBar& _xbar,
+ const std::string& _name) :
+ Layer(_port, _xbar, _name)
+ {}
protected:
-
- void sendRetry(MasterPort* retry_port)
- { retry_port->sendRetryResp(); }
+ void
+ sendRetry(RequestPort* retry_port) override
+ {
+ retry_port->sendRetryResp();
+ }
};
- class SnoopRespLayer : public Layer<SlavePort,MasterPort>
+ class SnoopRespLayer : public Layer<ResponsePort, RequestPort>
{
public:
/**
* @param _xbar the crossbar this layer belongs to
* @param _name the layer's name
*/
- SnoopRespLayer(MasterPort& _port, BaseXBar& _xbar,
+ SnoopRespLayer(RequestPort& _port, BaseXBar& _xbar,
const std::string& _name) :
- Layer(_port, _xbar, _name) {}
+ Layer(_port, _xbar, _name)
+ {}
protected:
- void sendRetry(SlavePort* retry_port)
- { retry_port->sendRetrySnoopResp(); }
+ void
+ sendRetry(ResponsePort* retry_port) override
+ {
+ retry_port->sendRetrySnoopResp();
+ }
};
/**
* and to decode the address.
*/
const Cycles frontendLatency;
- /** Cycles of forward latency */
const Cycles forwardLatency;
- /** Cycles of response latency */
const Cycles responseLatency;
+ /** Cycles the layer is occupied processing the packet header */
+ const Cycles headerLatency;
/** the width of the xbar in bytes */
const uint32_t width;
* Function called by the port when the crossbar is recieving a
* range change.
*
- * @param master_port_id id of the port that received the change
+ * @param mem_side_port_id id of the port that received the change
*/
- virtual void recvRangeChange(PortID master_port_id);
+ virtual void recvRangeChange(PortID mem_side_port_id);
/**
* Find which port connected to this crossbar (if any) should be
void calcPacketTiming(PacketPtr pkt, Tick header_delay);
/**
- * Remember for each of the master ports of the crossbar if we got
- * an address range from the connected slave. For convenience,
- * also keep track of if we got ranges from all the slave modules
+ * Remember for each of the memory-side ports of the crossbar if we got
+ * an address range from the connected CPU-side ports. For convenience,
+ * also keep track of if we got ranges from all the CPU-side-port modules
* or not.
*/
std::vector<bool> gotAddrRanges;
bool gotAllAddrRanges;
- /** The master and slave ports of the crossbar */
- std::vector<QueuedSlavePort*> slavePorts;
- std::vector<MasterPort*> masterPorts;
+ /** The memory-side ports and CPU-side ports of the crossbar */
+ std::vector<QueuedResponsePort*> cpuSidePorts;
+ std::vector<RequestPort*> memSidePorts;
/** Port that handles requests that don't match any of the interfaces.*/
PortID defaultPortID;
* crossbar. The transaction distribution is globally counting
* different types of commands. The packet count and total packet
* size are two-dimensional vectors that are indexed by the
- * slave port and master port id (thus the neighbouring master and
- * neighbouring slave), summing up both directions (request and
- * response).
+ * CPU-side port and memory-side port id (thus the neighbouring memory-side
+ * ports and neighbouring CPU-side ports), summing up both directions
+ * (request and response).
*/
Stats::Vector transDist;
Stats::Vector2d pktCount;
virtual ~BaseXBar();
- virtual void init();
-
/** A function used to return the port associated with this object. */
Port &getPort(const std::string &if_name,
PortID idx=InvalidPortID) override;
- virtual void regStats();
-
+ void regStats() override;
};
#endif //__MEM_XBAR_HH__
projects / gem5.git / blobdiff