/*
- * Copyright (c) 2011-2012 ARM Limited
+ * Copyright (c) 2011-2013 ARM Limited
* All rights reserved
*
* The license below extends only to copyright in the software and shall
/**
* @file
- * Declaration of a bus object.
+ * Declaration of an abstract bus base class.
*/
#ifndef __MEM_BUS_HH__
#define __MEM_BUS_HH__
-#include <list>
+#include <deque>
#include <set>
-#include <string>
-#include "base/range.hh"
-#include "base/range_map.hh"
+#include "base/addr_range_map.hh"
#include "base/types.hh"
#include "mem/mem_object.hh"
-#include "mem/packet.hh"
-#include "mem/port.hh"
-#include "params/Bus.hh"
-#include "sim/eventq.hh"
+#include "params/BaseBus.hh"
-class Bus : public MemObject
+/**
+ * The base bus contains the common elements of the non-coherent and
+ * coherent bus. It is an abstract class that does not have any of the
+ * functionality relating to the actual reception and transmission of
+ * packets, as this is left for the subclasses.
+ *
+ * The BaseBus is responsible for the basic flow control (busy or
+ * not), the administration of retries, and the address decoding.
+ */
+class BaseBus : public MemObject
{
+ protected:
+
/**
- * Declaration of the bus slave port type, one will be
- * instantiated for each of the master interfaces connecting to
- * the bus.
+ * A bus layer is an internal bus structure with its own flow
+ * control and arbitration. Hence, a single-layer bus mimics a
+ * traditional off-chip tri-state bus (like PCI), where only one
+ * set of wires are shared. For on-chip buses, a good starting
+ * point is to have three layers, for requests, responses, and
+ * snoop responses respectively (snoop requests are instantaneous
+ * and do not need any flow control or arbitration). This case is
+ * similar to AHB and some OCP configurations.
+ *
+ * As a further extensions beyond the three-layer bus, a future
+ * multi-layer bus has with one layer per connected slave port
+ * provides a full or partial crossbar, like AXI, OCP, PCIe etc.
+ *
+ * The template parameter, PortClass, indicates the destination
+ * port type for the bus. 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.
*/
- class BusSlavePort : public SlavePort
+ template <typename PortClass>
+ class Layer : public Drainable
{
- private:
- /** A pointer to the bus to which this port belongs. */
- Bus *bus;
public:
- /** Constructor for the BusSlavePort.*/
- BusSlavePort(const std::string &_name, Bus *_bus, PortID _id)
- : SlavePort(_name, _bus, _id), bus(_bus)
- { }
+ /**
+ * Create a bus layer and give it a name. The bus layer uses
+ * the bus an event manager.
+ *
+ * @param _bus the bus this layer belongs to
+ * @param _name the layer's name
+ */
+ Layer(BaseBus& _bus, const std::string& _name);
- protected:
+ /**
+ * Drain according to the normal semantics, so that the bus
+ * can tell the layer to drain, and pass an event to signal
+ * back when drained.
+ *
+ * @param de drain event to call once drained
+ *
+ * @return 1 if busy or waiting to retry, or 0 if idle
+ */
+ unsigned int drain(DrainManager *dm);
/**
- * When receiving a timing request, pass it to the bus.
+ * Get the bus layer's name
*/
- virtual bool recvTimingReq(PacketPtr pkt)
- { return bus->recvTimingReq(pkt, id); }
+ const std::string name() const { return bus.name() + _name; }
+
/**
- * When receiving a timing snoop response, pass it to the bus.
+ * Determine if the bus layer accepts a packet from a specific
+ * port. If not, the port in question is also added to the
+ * retry list. In either case the state of the layer is updated
+ * accordingly.
+ *
+ * @param port Source port resenting the packet
+ *
+ * @return True if the bus layer accepts the packet
*/
- virtual bool recvTimingSnoopResp(PacketPtr pkt)
- { return bus->recvTimingSnoopResp(pkt, id); }
+ bool tryTiming(PortClass* port);
/**
- * When receiving an atomic request, pass it to the bus.
+ * Deal with a destination port accepting a packet by potentially
+ * removing the source port from the retry list (if retrying) and
+ * occupying the bus layer accordingly.
+ *
+ * @param busy_time Time to spend as a result of a successful send
*/
- virtual Tick recvAtomic(PacketPtr pkt)
- { return bus->recvAtomic(pkt, id); }
+ void succeededTiming(Tick busy_time);
/**
- * When receiving a functional request, pass it to the bus.
+ * Deal with a destination port not accepting a packet by
+ * potentially adding the source port to the retry list (if
+ * not already at the front) and occupying the bus layer
+ * accordingly.
+ *
+ * @param busy_time Time to spend as a result of a failed send
*/
- virtual void recvFunctional(PacketPtr pkt)
- { bus->recvFunctional(pkt, id); }
+ void failedTiming(PortClass* port, Tick busy_time);
+
+ /** Occupy the bus layer until until */
+ void occupyLayer(Tick until);
/**
- * When receiving a retry, pass it to the bus.
+ * Send a retry to the port at the head of the retryList. The
+ * caller must ensure that the list is not empty.
*/
- virtual void recvRetry()
- { panic("Bus slave ports always succeed and should never retry.\n"); }
-
- // This should return all the 'owned' addresses that are
- // downstream from this bus, yes? That is, the union of all
- // the 'owned' address ranges of all the other interfaces on
- // this bus...
- virtual AddrRangeList getAddrRanges()
- { return bus->getAddrRanges(); }
-
- // Ask the bus to ask everyone on the bus what their block size is and
- // take the max of it. This might need to be changed a bit if we ever
- // support multiple block sizes.
- virtual unsigned deviceBlockSize() const
- { return bus->findBlockSize(); }
+ void retryWaiting();
- };
+ /**
+ * Handler a retry from a neighbouring module. Eventually this
+ * should be all encapsulated in the bus. This wraps
+ * retryWaiting by verifying that there are ports waiting
+ * before calling retryWaiting.
+ */
+ void recvRetry();
- /**
- * Declaration of the bus master port type, one will be
- * instantiated for each of the slave interfaces connecting to the
- * bus.
- */
- class BusMasterPort : public MasterPort
- {
private:
- /** A pointer to the bus to which this port belongs. */
- Bus *bus;
- public:
+ /** The bus this layer is a part of. */
+ BaseBus& bus;
- /** Constructor for the BusMasterPort.*/
- BusMasterPort(const std::string &_name, Bus *_bus, PortID _id)
- : MasterPort(_name, _bus, _id), bus(_bus)
- { }
+ /** A name for this layer. */
+ std::string _name;
/**
- * Determine if this port should be considered a snooper. This
- * is determined by the bus.
- *
- * @return a boolean that is true if this port is snooping
+ * We declare an enum to track the state of the bus layer. The
+ * starting point is an idle state where the bus layer is
+ * waiting for a packet to arrive. Upon arrival, the bus layer
+ * transitions to the busy state, where it remains either
+ * until the packet transfer is done, or the header time is
+ * spent. Once the bus layer leaves the busy state, it can
+ * either go back to idle, if no packets have arrived while it
+ * was busy, or the bus layer goes on to retry the first port
+ * on the retryList. A similar transition takes place from
+ * idle to retry if the bus layer receives a retry from one of
+ * its connected ports. The retry state lasts until the port
+ * in questions calls sendTiming and returns control to the
+ * bus layer, or goes to a busy state if the port does not
+ * immediately react to the retry by calling sendTiming.
*/
- virtual bool isSnooping() const
- { return bus->isSnooping(); }
+ enum State { IDLE, BUSY, RETRY };
- protected:
+ /** track the state of the bus layer */
+ State state;
- /**
- * When receiving a timing response, pass it to the bus.
- */
- virtual bool recvTimingResp(PacketPtr pkt)
- { return bus->recvTimingResp(pkt, id); }
+ /** manager to signal when drained */
+ DrainManager *drainManager;
/**
- * When receiving a timing snoop request, pass it to the bus.
+ * An array of ports that retry should be called
+ * on because the original send failed for whatever reason.
*/
- virtual void recvTimingSnoopReq(PacketPtr pkt)
- { return bus->recvTimingSnoopReq(pkt, id); }
+ std::deque<PortClass*> retryList;
/**
- * When receiving an atomic snoop request, pass it to the bus.
+ * Port that we are currently in the process of telling to
+ * retry a previously failed attempt to perform a timing
+ * transaction. This is a valid port when in the retry state,
+ * and NULL when in busy or idle.
*/
- virtual Tick recvAtomicSnoop(PacketPtr pkt)
- { return bus->recvAtomicSnoop(pkt, id); }
+ PortClass* retryingPort;
/**
- * When receiving a functional snoop request, pass it to the bus.
+ * Release the bus layer after being occupied and return to an
+ * idle state where we proceed to send a retry to any
+ * potential waiting port, or drain if asked to do so.
*/
- virtual void recvFunctionalSnoop(PacketPtr pkt)
- { bus->recvFunctionalSnoop(pkt, id); }
-
- /** When reciving a range change from the peer port (at id),
- pass it to the bus. */
- virtual void recvRangeChange()
- { bus->recvRangeChange(id); }
-
- /** When reciving a retry from the peer port (at id),
- pass it to the bus. */
- virtual void recvRetry()
- { bus->recvRetry(); }
+ void releaseLayer();
- // Ask the bus to ask everyone on the bus what their block size is and
- // take the max of it. This might need to be changed a bit if we ever
- // support multiple block sizes.
- virtual unsigned deviceBlockSize() const
- { return bus->findBlockSize(); }
+ /** event used to schedule a release of the layer */
+ EventWrapper<Layer, &Layer::releaseLayer> releaseEvent;
};
- /** the clock speed for the bus */
- int clock;
/** cycles of overhead per transaction */
- int headerCycles;
+ const Cycles headerCycles;
/** the width of the bus in bytes */
- int width;
- /** the next tick at which the bus will be idle */
- Tick tickNextIdle;
-
- Event * drainEvent;
-
- typedef range_map<Addr, PortID>::iterator PortIter;
- range_map<Addr, PortID> portMap;
+ const uint32_t width;
- AddrRangeList defaultRange;
+ typedef AddrRangeMap<PortID>::iterator PortMapIter;
+ typedef AddrRangeMap<PortID>::const_iterator PortMapConstIter;
+ AddrRangeMap<PortID> portMap;
- std::vector<SlavePort*> snoopPorts;
+ /** all contigous ranges seen by this bus */
+ AddrRangeList busRanges;
- /**
- * Store the outstanding requests so we can determine which ones
- * we generated and which ones were merely forwarded. This is used
- * in the coherent bus when coherency responses come back.
- */
- std::set<RequestPtr> outstandingReq;
-
- /** Function called by the port when the bus is recieving a Timing
- request packet.*/
- bool recvTimingReq(PacketPtr pkt, PortID slave_port_id);
-
- /** Function called by the port when the bus is recieving a Timing
- response packet.*/
- bool recvTimingResp(PacketPtr pkt, PortID master_port_id);
-
- /** Function called by the port when the bus is recieving a timing
- snoop request.*/
- void recvTimingSnoopReq(PacketPtr pkt, PortID master_port_id);
-
- /** Function called by the port when the bus is recieving a timing
- snoop response.*/
- bool recvTimingSnoopResp(PacketPtr pkt, PortID slave_port_id);
-
- /**
- * Forward a timing packet to our snoopers, potentially excluding
- * one of the connected coherent masters to avoid sending a packet
- * back to where it came from.
- *
- * @param pkt Packet to forward
- * @param exclude_slave_port_id Id of slave port to exclude
- */
- void forwardTiming(PacketPtr pkt, PortID exclude_slave_port_id);
-
- /**
- * Determine if the bus is to be considered occupied when being
- * presented with a packet from a specific port. If so, the port
- * in question is also added to the retry list.
- *
- * @param port Source port on the bus presenting the packet
- *
- * @return True if the bus is to be considered occupied
- */
- bool isOccupied(Port* port);
-
- /**
- * Deal with a destination port accepting a packet by potentially
- * removing the source port from the retry list (if retrying) and
- * occupying the bus accordingly.
- *
- * @param busy_time Time to spend as a result of a successful send
- */
- void succeededTiming(Tick busy_time);
-
- /** Function called by the port when the bus is recieving a Atomic
- transaction.*/
- Tick recvAtomic(PacketPtr pkt, PortID slave_port_id);
-
- /** Function called by the port when the bus is recieving an
- atomic snoop transaction.*/
- Tick recvAtomicSnoop(PacketPtr pkt, PortID master_port_id);
-
- /**
- * Forward an atomic packet to our snoopers, potentially excluding
- * one of the connected coherent masters to avoid sending a packet
- * back to where it came from.
- *
- * @param pkt Packet to forward
- * @param exclude_slave_port_id Id of slave port to exclude
- *
- * @return a pair containing the snoop response and snoop latency
- */
- std::pair<MemCmd, Tick> forwardAtomic(PacketPtr pkt,
- PortID exclude_slave_port_id);
-
- /** Function called by the port when the bus is recieving a Functional
- transaction.*/
- void recvFunctional(PacketPtr pkt, PortID slave_port_id);
-
- /** Function called by the port when the bus is recieving a functional
- snoop transaction.*/
- void recvFunctionalSnoop(PacketPtr pkt, PortID master_port_id);
-
- /**
- * Forward a functional packet to our snoopers, potentially
- * excluding one of the connected coherent masters to avoid
- * sending a packet back to where it came from.
- *
- * @param pkt Packet to forward
- * @param exclude_slave_port_id Id of slave port to exclude
- */
- void forwardFunctional(PacketPtr pkt, PortID exclude_slave_port_id);
-
- /** Timing function called by port when it is once again able to process
- * requests. */
- void recvRetry();
+ AddrRange defaultRange;
/**
* Function called by the port when the bus is recieving a range change.
struct PortCache {
bool valid;
PortID id;
- Addr start;
- Addr end;
+ AddrRange range;
};
PortCache portCache[3];
// Checks the cache and returns the id of the port that has the requested
// address within its range
- inline PortID checkPortCache(Addr addr) {
- if (portCache[0].valid && addr >= portCache[0].start &&
- addr < portCache[0].end) {
+ inline PortID checkPortCache(Addr addr) const {
+ if (portCache[0].valid && portCache[0].range.contains(addr)) {
return portCache[0].id;
}
- if (portCache[1].valid && addr >= portCache[1].start &&
- addr < portCache[1].end) {
+ if (portCache[1].valid && portCache[1].range.contains(addr)) {
return portCache[1].id;
}
- if (portCache[2].valid && addr >= portCache[2].start &&
- addr < portCache[2].end) {
+ if (portCache[2].valid && portCache[2].range.contains(addr)) {
return portCache[2].id;
}
}
// Clears the earliest entry of the cache and inserts a new port entry
- inline void updatePortCache(short id, Addr start, Addr end) {
+ inline void updatePortCache(short id, const AddrRange& range) {
portCache[2].valid = portCache[1].valid;
portCache[2].id = portCache[1].id;
- portCache[2].start = portCache[1].start;
- portCache[2].end = portCache[1].end;
+ portCache[2].range = portCache[1].range;
portCache[1].valid = portCache[0].valid;
portCache[1].id = portCache[0].id;
- portCache[1].start = portCache[0].start;
- portCache[1].end = portCache[0].end;
+ portCache[1].range = portCache[0].range;
portCache[0].valid = true;
portCache[0].id = id;
- portCache[0].start = start;
- portCache[0].end = end;
+ portCache[0].range = range;
}
// Clears the cache. Needs to be called in constructor.
*
* @return a list of non-overlapping address ranges
*/
- AddrRangeList getAddrRanges();
+ AddrRangeList getAddrRanges() const;
/**
- * Determine if the bus port is snooping or not.
- *
- * @return a boolean indicating if this port is snooping or not
- */
- bool isSnooping() const;
-
- /** Calculate the timing parameters for the packet. Updates the
- * firstWordTime and finishTime fields of the packet object.
- * Returns the tick at which the packet header is completed (which
- * will be all that is sent if the target rejects the packet).
+ * Calculate the timing parameters for the packet. Updates the
+ * busFirstWordDelay and busLastWordDelay fields of the packet
+ * object with the relative number of ticks required to transmit
+ * the header and the first word, and the last word, respectively.
*/
- Tick calcPacketTiming(PacketPtr pkt);
-
- /** Occupy the bus until until */
- void occupyBus(Tick until);
+ void calcPacketTiming(PacketPtr pkt);
/**
- * Release the bus after being occupied and return to an idle
- * state where we proceed to send a retry to any potential waiting
- * port, or drain if asked to do so.
- */
- void releaseBus();
-
- /**
- * Send a retry to the port at the head of the retryList. The
- * caller must ensure that the list is not empty.
+ * Ask everyone on the bus what their size is and determine the
+ * bus size as either the maximum, or if no device specifies a
+ * block size return the default.
+ *
+ * @return the max of all the sizes or the default if none is set
*/
- void retryWaiting();
+ unsigned deviceBlockSize() const;
/**
- * Ask everyone on the bus what their size is
- *
- * @return the max of all the sizes
+ * Remember for each of the master ports of the bus 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 or
+ * not.
*/
- unsigned findBlockSize();
-
- // event used to schedule a release of the bus
- EventWrapper<Bus, &Bus::releaseBus> busIdleEvent;
-
- bool inRetry;
- std::set<PortID> inRecvRangeChange;
+ std::vector<bool> gotAddrRanges;
+ bool gotAllAddrRanges;
/** The master and slave ports of the bus */
std::vector<SlavePort*> slavePorts;
std::vector<MasterPort*> masterPorts;
+ /** Convenience typedefs. */
typedef std::vector<SlavePort*>::iterator SlavePortIter;
+ typedef std::vector<MasterPort*>::iterator MasterPortIter;
typedef std::vector<SlavePort*>::const_iterator SlavePortConstIter;
-
- /** An array of pointers to ports that retry should be called on because the
- * original send failed for whatever reason.*/
- std::list<Port*> retryList;
-
- void addToRetryList(Port* port)
- {
- if (!inRetry) {
- // The device wasn't retrying a packet, or wasn't at an
- // appropriate time.
- retryList.push_back(port);
- } else {
- if (!retryList.empty() && port == retryList.front()) {
- // The device was retrying a packet. It didn't work,
- // so we'll leave it at the head of the retry list.
- inRetry = false;
- } else {
- // We are in retry, but not for this port, put it at
- // the end.
- retryList.push_back(port);
- }
- }
- }
+ typedef std::vector<MasterPort*>::const_iterator MasterPortConstIter;
/** Port that handles requests that don't match any of the interfaces.*/
PortID defaultPortID;
address not handled by another port and not in default device's
range will cause a fatal error. If false, just send all
addresses not handled by another port to default device. */
- bool useDefaultRange;
+ const bool useDefaultRange;
- unsigned defaultBlockSize;
- unsigned cachedBlockSize;
- bool cachedBlockSizeValid;
+ uint32_t blockSize;
- public:
+ BaseBus(const BaseBusParams *p);
- /** A function used to return the port associated with this bus object. */
- virtual MasterPort& getMasterPort(const std::string& if_name, int idx = -1);
- virtual SlavePort& getSlavePort(const std::string& if_name, int idx = -1);
+ virtual ~BaseBus();
+
+ public:
virtual void init();
- virtual void startup();
- unsigned int drain(Event *de);
+ /** A function used to return the port associated with this bus object. */
+ BaseMasterPort& getMasterPort(const std::string& if_name,
+ PortID idx = InvalidPortID);
+ BaseSlavePort& getSlavePort(const std::string& if_name,
+ PortID idx = InvalidPortID);
+
+ virtual unsigned int drain(DrainManager *dm) = 0;
- Bus(const BusParams *p);
};
#endif //__MEM_BUS_HH__
projects / gem5.git / blobdiff