/*
+ * Copyright (c) 2011-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) 2006 The Regents of The University of Michigan
* All rights reserved.
*
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* Authors: Ali Saidi
+ * Andreas Hansson
+ * William Wang
*/
/**
* Definition of a bus object.
*/
-#include <algorithm>
-#include <limits>
-
#include "base/misc.hh"
#include "base/trace.hh"
+#include "debug/Bus.hh"
+#include "debug/BusAddrRanges.hh"
+#include "debug/Drain.hh"
#include "mem/bus.hh"
-#include "sim/builder.hh"
-Port *
-Bus::getPort(const std::string &if_name, int idx)
+BaseBus::BaseBus(const BaseBusParams *p)
+ : MemObject(p),
+ headerCycles(p->header_cycles), width(p->width),
+ gotAddrRanges(p->port_default_connection_count +
+ p->port_master_connection_count, false),
+ gotAllAddrRanges(false), defaultPortID(InvalidPortID),
+ useDefaultRange(p->use_default_range),
+ blockSize(p->block_size)
+{}
+
+BaseBus::~BaseBus()
{
- if (if_name == "default") {
- if (defaultPort == NULL) {
- defaultPort = new BusPort(csprintf("%s-default",name()), this,
- defaultId);
- cachedBlockSizeValid = false;
- return defaultPort;
- } else
- fatal("Default port already set\n");
- }
- int id;
- if (if_name == "functional") {
- if (!funcPort) {
- id = maxId++;
- funcPort = new BusPort(csprintf("%s-p%d-func", name(), id), this, id);
- funcPortId = id;
- interfaces[id] = funcPort;
- }
- return funcPort;
+ for (MasterPortIter m = masterPorts.begin(); m != masterPorts.end();
+ ++m) {
+ delete *m;
}
- // if_name ignored? forced to be empty?
- id = maxId++;
- assert(maxId < std::numeric_limits<typeof(maxId)>::max());
- BusPort *bp = new BusPort(csprintf("%s-p%d", name(), id), this, id);
- interfaces[id] = bp;
- cachedBlockSizeValid = false;
- return bp;
+ for (SlavePortIter s = slavePorts.begin(); s != slavePorts.end();
+ ++s) {
+ delete *s;
+ }
}
void
-Bus::deletePortRefs(Port *p)
+BaseBus::init()
{
+ // determine the maximum peer block size, look at both the
+ // connected master and slave modules
+ uint32_t peer_block_size = 0;
- BusPort *bp = dynamic_cast<BusPort*>(p);
- if (bp == NULL)
- panic("Couldn't convert Port* to BusPort*\n");
- // If this is our one functional port
- if (funcPort == bp)
- return;
- interfaces.erase(bp->getId());
- delete bp;
-}
+ for (MasterPortConstIter m = masterPorts.begin(); m != masterPorts.end();
+ ++m) {
+ peer_block_size = std::max((*m)->peerBlockSize(), peer_block_size);
+ }
-/** Get the ranges of anyone other buses that we are connected to. */
-void
-Bus::init()
-{
- m5::hash_map<short,BusPort*>::iterator intIter;
+ for (SlavePortConstIter s = slavePorts.begin(); s != slavePorts.end();
+ ++s) {
+ peer_block_size = std::max((*s)->peerBlockSize(), peer_block_size);
+ }
- for (intIter = interfaces.begin(); intIter != interfaces.end(); intIter++)
- intIter->second->sendStatusChange(Port::RangeChange);
-}
+ // if the peers do not have a block size, use the default value
+ // set through the bus parameters
+ if (peer_block_size != 0)
+ blockSize = peer_block_size;
-Bus::BusFreeEvent::BusFreeEvent(Bus *_bus) : Event(&mainEventQueue), bus(_bus)
-{}
+ // check if the block size is a value known to work
+ if (!(blockSize == 16 || blockSize == 32 || blockSize == 64 ||
+ blockSize == 128))
+ warn_once("Block size is neither 16, 32, 64 or 128 bytes.\n");
+}
-void Bus::BusFreeEvent::process()
+BaseMasterPort &
+BaseBus::getMasterPort(const std::string &if_name, PortID idx)
{
- bus->recvRetry(-1);
+ if (if_name == "master" && idx < masterPorts.size()) {
+ // the master port index translates directly to the vector position
+ return *masterPorts[idx];
+ } else if (if_name == "default") {
+ return *masterPorts[defaultPortID];
+ } else {
+ return MemObject::getMasterPort(if_name, idx);
+ }
}
-const char * Bus::BusFreeEvent::description()
+BaseSlavePort &
+BaseBus::getSlavePort(const std::string &if_name, PortID idx)
{
- return "bus became available";
+ if (if_name == "slave" && idx < slavePorts.size()) {
+ // the slave port index translates directly to the vector position
+ return *slavePorts[idx];
+ } else {
+ return MemObject::getSlavePort(if_name, idx);
+ }
}
-void Bus::occupyBus(PacketPtr pkt)
+Tick
+BaseBus::calcPacketTiming(PacketPtr pkt)
{
- //Bring tickNextIdle up to the present tick
- //There is some potential ambiguity where a cycle starts, which might make
- //a difference when devices are acting right around a cycle boundary. Using
- //a < allows things which happen exactly on a cycle boundary to take up
- //only the following cycle. Anything that happens later will have to "wait"
- //for the end of that cycle, and then start using the bus after that.
- if (tickNextIdle < curTick) {
- tickNextIdle = curTick;
- if (tickNextIdle % clock != 0)
- tickNextIdle = curTick - (curTick % clock) + clock;
- }
+ // determine the current time rounded to the closest following
+ // clock edge
+ Tick now = nextCycle();
+
+ Tick headerTime = now + headerCycles * clock;
// The packet will be sent. Figure out how long it occupies the bus, and
// how much of that time is for the first "word", aka bus width.
int numCycles = 0;
- // Requests need one cycle to send an address
- if (pkt->isRequest())
- numCycles++;
- else if (pkt->isResponse() || pkt->hasData()) {
+ if (pkt->hasData()) {
// If a packet has data, it needs ceil(size/width) cycles to send it
- // We're using the "adding instead of dividing" trick again here
- if (pkt->hasData()) {
- int dataSize = pkt->getSize();
- numCycles += dataSize/width;
- if (dataSize % width)
- numCycles++;
- } else {
- // If the packet didn't have data, it must have been a response.
- // Those use the bus for one cycle to send their data.
+ int dataSize = pkt->getSize();
+ numCycles += dataSize/width;
+ if (dataSize % width)
numCycles++;
- }
}
// The first word will be delivered after the current tick, the delivery
// of the address if any, and one bus cycle to deliver the data
- pkt->firstWordTime =
- tickNextIdle +
- pkt->isRequest() ? clock : 0 +
- clock;
-
- //Advance it numCycles bus cycles.
- //XXX Should this use the repeated addition trick as well?
- tickNextIdle += (numCycles * clock);
- if (!busIdle.scheduled()) {
- busIdle.schedule(tickNextIdle);
- } else {
- busIdle.reschedule(tickNextIdle);
- }
- DPRINTF(Bus, "The bus is now occupied from tick %d to %d\n",
- curTick, tickNextIdle);
+ pkt->firstWordTime = headerTime + clock;
+
+ pkt->finishTime = headerTime + numCycles * clock;
+
+ return headerTime;
+}
- // The bus will become idle once the current packet is delivered.
- pkt->finishTime = tickNextIdle;
+template <typename PortClass>
+BaseBus::Layer<PortClass>::Layer(BaseBus& _bus, const std::string& _name,
+ Tick _clock) :
+ Drainable(),
+ bus(_bus), _name(_name), state(IDLE), clock(_clock), drainManager(NULL),
+ releaseEvent(this)
+{
}
-/** Function called by the port when the bus is receiving a Timing
- * transaction.*/
+template <typename PortClass>
+void BaseBus::Layer<PortClass>::occupyLayer(Tick until)
+{
+ // ensure the state is busy or in retry and never idle at this
+ // point, as the bus should transition from idle as soon as it has
+ // decided to forward the packet to prevent any follow-on calls to
+ // sendTiming seeing an unoccupied bus
+ assert(state != IDLE);
+
+ // note that we do not change the bus state here, if we are going
+ // from idle to busy it is handled by tryTiming, and if we
+ // are in retry we should remain in retry such that
+ // succeededTiming still sees the accurate state
+
+ // until should never be 0 as express snoops never occupy the bus
+ assert(until != 0);
+ bus.schedule(releaseEvent, until);
+
+ DPRINTF(BaseBus, "The bus is now busy from tick %d to %d\n",
+ curTick(), until);
+}
+
+template <typename PortClass>
bool
-Bus::recvTiming(PacketPtr pkt)
+BaseBus::Layer<PortClass>::tryTiming(PortClass* port)
{
- int port_id;
- DPRINTF(Bus, "recvTiming: packet src %d dest %d addr 0x%x cmd %s\n",
- pkt->getSrc(), pkt->getDest(), pkt->getAddr(), pkt->cmdString());
-
- BusPort *pktPort;
- if (pkt->getSrc() == defaultId)
- pktPort = defaultPort;
- else pktPort = interfaces[pkt->getSrc()];
-
- // If the bus is busy, or other devices are in line ahead of the current
- // one, put this device on the retry list.
- if (!(pkt->isResponse() || pkt->isExpressSnoop()) &&
- (tickNextIdle > curTick ||
- (retryList.size() && (!inRetry || pktPort != retryList.front()))))
- {
- addToRetryList(pktPort);
- DPRINTF(Bus, "recvTiming: Bus is busy, returning false\n");
+ // first we see if the bus is busy, next we check if we are in a
+ // retry with a port other than the current one
+ if (state == BUSY || (state == RETRY && port != retryList.front())) {
+ // put the port at the end of the retry list
+ retryList.push_back(port);
return false;
}
- short dest = pkt->getDest();
+ // update the state which is shared for request, response and
+ // snoop responses, if we were idle we are now busy, if we are in
+ // a retry, then do not change
+ if (state == IDLE)
+ state = BUSY;
- if (dest == Packet::Broadcast) {
- port_id = findPort(pkt->getAddr());
- timingSnoop(pkt, interfaces[port_id]);
+ return true;
+}
- if (pkt->memInhibitAsserted()) {
- //Cache-Cache transfer occuring
- if (inRetry) {
- retryList.front()->onRetryList(false);
- retryList.pop_front();
- inRetry = false;
- }
- occupyBus(pkt);
- DPRINTF(Bus, "recvTiming: Packet sucessfully sent\n");
- return true;
- }
- } else {
- assert(dest >= 0 && dest < maxId);
- assert(dest != pkt->getSrc()); // catch infinite loops
- port_id = dest;
+template <typename PortClass>
+void
+BaseBus::Layer<PortClass>::succeededTiming(Tick busy_time)
+{
+ // if a retrying port succeeded, also take it off the retry list
+ if (state == RETRY) {
+ DPRINTF(BaseBus, "Remove retry from list %s\n",
+ retryList.front()->name());
+ retryList.pop_front();
+ state = BUSY;
}
- occupyBus(pkt);
-
- if (port_id != pkt->getSrc()) {
- if (interfaces[port_id]->sendTiming(pkt)) {
- // Packet was successfully sent. Return true.
- // Also take care of retries
- if (inRetry) {
- DPRINTF(Bus, "Remove retry from list %d\n",
- retryList.front()->getId());
- retryList.front()->onRetryList(false);
- retryList.pop_front();
- inRetry = false;
- }
- return true;
- }
+ // we should either have gone from idle to busy in the
+ // tryTiming test, or just gone from a retry to busy
+ assert(state == BUSY);
- // Packet not successfully sent. Leave or put it on the retry list.
- // illegal to block responses... can lead to deadlock
- assert(!pkt->isResponse());
- DPRINTF(Bus, "Adding2 a retry to RETRY list %d\n",
- pktPort->getId());
- addToRetryList(pktPort);
- return false;
- }
- else {
- //Forwarding up from responder, just return true;
- DPRINTF(Bus, "recvTiming: can we be here?\n");
- return true;
- }
+ // occupy the bus accordingly
+ occupyLayer(busy_time);
}
+template <typename PortClass>
void
-Bus::recvRetry(int id)
+BaseBus::Layer<PortClass>::failedTiming(PortClass* port, Tick busy_time)
{
- // If there's anything waiting, and the bus isn't busy...
- if (retryList.size() && curTick >= tickNextIdle) {
- //retryingPort = retryList.front();
- inRetry = true;
- DPRINTF(Bus, "Sending a retry to %s\n", retryList.front()->getPeer()->name());
- retryList.front()->sendRetry();
- // If inRetry is still true, sendTiming wasn't called
- if (inRetry)
- {
- retryList.front()->onRetryList(false);
- retryList.pop_front();
- inRetry = false;
-
- //Bring tickNextIdle up to the present
- while (tickNextIdle < curTick)
- tickNextIdle += clock;
-
- //Burn a cycle for the missed grant.
- tickNextIdle += clock;
-
- busIdle.reschedule(tickNextIdle, true);
- }
- }
- //If we weren't able to drain before, we might be able to now.
- if (drainEvent && retryList.size() == 0 && curTick >= tickNextIdle) {
- drainEvent->process();
- // Clear the drain event once we're done with it.
- drainEvent = NULL;
+ // if we are not in a retry, i.e. busy (but never idle), or we are
+ // in a retry but not for the current port, then add the port at
+ // the end of the retry list
+ if (state != RETRY || port != retryList.front()) {
+ retryList.push_back(port);
}
-}
-int
-Bus::findPort(Addr addr)
-{
- /* An interval tree would be a better way to do this. --ali. */
- int dest_id = -1;
-
- PortIter i = portMap.find(RangeSize(addr,1));
- if (i != portMap.end())
- dest_id = i->second;
-
- // Check if this matches the default range
- if (dest_id == -1) {
- for (AddrRangeIter iter = defaultRange.begin();
- iter != defaultRange.end(); iter++) {
- if (*iter == addr) {
- DPRINTF(Bus, " found addr %#llx on default\n", addr);
- return defaultId;
- }
- }
-
- if (responderSet) {
- panic("Unable to find destination for addr (user set default "
- "responder): %#llx", addr);
- } else {
- DPRINTF(Bus, "Unable to find destination for addr: %#llx, will use "
- "default port", addr);
-
- return defaultId;
- }
- }
+ // even if we retried the current one and did not succeed,
+ // we are no longer retrying but instead busy
+ state = BUSY;
- return dest_id;
+ // occupy the bus accordingly
+ occupyLayer(busy_time);
}
+template <typename PortClass>
void
-Bus::functionalSnoop(PacketPtr pkt, Port *responder)
+BaseBus::Layer<PortClass>::releaseLayer()
{
- // The packet may be changed by another bus on snoops, restore the
- // id after each
- int src_id = pkt->getSrc();
-
- assert(pkt->isRequest()); // hasn't already been satisfied
-
- for (SnoopIter s_iter = snoopPorts.begin();
- s_iter != snoopPorts.end();
- s_iter++) {
- BusPort *p = *s_iter;
- if (p != responder && p->getId() != src_id) {
- p->sendFunctional(pkt);
- }
- if (pkt->isResponse()) {
- break;
- }
- pkt->setSrc(src_id);
+ // releasing the bus means we should now be idle
+ assert(state == BUSY);
+ assert(!releaseEvent.scheduled());
+
+ // update the state
+ state = IDLE;
+
+ // bus is now idle, so if someone is waiting we can retry
+ if (!retryList.empty()) {
+ // note that we block (return false on recvTiming) both
+ // because the bus is busy and because the destination is
+ // busy, and in the latter case the bus may be released before
+ // we see a retry from the destination
+ retryWaiting();
+ } else if (drainManager) {
+ DPRINTF(Drain, "Bus done draining, signaling drain manager\n");
+ //If we weren't able to drain before, do it now.
+ drainManager->signalDrainDone();
+ // Clear the drain event once we're done with it.
+ drainManager = NULL;
}
}
-bool
-Bus::timingSnoop(PacketPtr pkt, Port* responder)
+template <typename PortClass>
+void
+BaseBus::Layer<PortClass>::retryWaiting()
{
- for (SnoopIter s_iter = snoopPorts.begin();
- s_iter != snoopPorts.end();
- s_iter++) {
- BusPort *p = *s_iter;
- if (p != responder && p->getId() != pkt->getSrc()) {
- bool success = p->sendTiming(pkt);
- if (!success)
- return false;
- }
- }
+ // this should never be called with an empty retry list
+ assert(!retryList.empty());
- return true;
-}
+ // we always go to retrying from idle
+ assert(state == IDLE);
+ // update the state which is shared for request, response and
+ // snoop responses
+ state = RETRY;
-/** Function called by the port when the bus is receiving a Atomic
- * transaction.*/
-Tick
-Bus::recvAtomic(PacketPtr pkt)
-{
- DPRINTF(Bus, "recvAtomic: packet src %d dest %d addr 0x%x cmd %s\n",
- pkt->getSrc(), pkt->getDest(), pkt->getAddr(), pkt->cmdString());
- assert(pkt->getDest() == Packet::Broadcast);
- assert(pkt->isRequest());
-
- // Variables for recording original command and snoop response (if
- // any)... if a snooper respondes, we will need to restore
- // original command so that additional snoops can take place
- // properly
- MemCmd orig_cmd = pkt->cmd;
- MemCmd snoop_response_cmd = MemCmd::InvalidCmd;
- Tick snoop_response_latency = 0;
- int orig_src = pkt->getSrc();
-
- int target_port_id = findPort(pkt->getAddr());
- Port *target_port = interfaces[target_port_id];
-
- SnoopIter s_end = snoopPorts.end();
- for (SnoopIter s_iter = snoopPorts.begin(); s_iter != s_end; s_iter++) {
- BusPort *p = *s_iter;
- // same port should not have both target addresses and snooping
- assert(p != target_port);
- if (p->getId() != pkt->getSrc()) {
- Tick latency = p->sendAtomic(pkt);
- if (pkt->isResponse()) {
- // response from snoop agent
- assert(pkt->cmd != orig_cmd);
- assert(pkt->memInhibitAsserted());
- // should only happen once
- assert(snoop_response_cmd == MemCmd::InvalidCmd);
- // save response state
- snoop_response_cmd = pkt->cmd;
- snoop_response_latency = latency;
- // restore original packet state for remaining snoopers
- pkt->cmd = orig_cmd;
- pkt->setSrc(orig_src);
- pkt->setDest(Packet::Broadcast);
- }
- }
- }
+ // note that we might have blocked on the receiving port being
+ // busy (rather than the bus itself) and now call retry before the
+ // destination called retry on the bus
+ retryList.front()->sendRetry();
- Tick response_latency = 0;
+ // If the bus is still in the retry state, sendTiming wasn't
+ // called in zero time (e.g. the cache does this)
+ if (state == RETRY) {
+ retryList.pop_front();
- // we can get requests sent up from the memory side of the bus for
- // snooping... don't send them back down!
- if (target_port_id != pkt->getSrc()) {
- response_latency = target_port->sendAtomic(pkt);
- }
+ //Burn a cycle for the missed grant.
- // if we got a response from a snooper, restore it here
- if (snoop_response_cmd != MemCmd::InvalidCmd) {
- // no one else should have responded
- assert(!pkt->isResponse());
- assert(pkt->cmd == orig_cmd);
- pkt->cmd = snoop_response_cmd;
- response_latency = snoop_response_latency;
- }
+ // update the state which is shared for request, response and
+ // snoop responses
+ state = BUSY;
+
+ // determine the current time rounded to the closest following
+ // clock edge
+ Tick now = bus.nextCycle();
- // why do we have this packet field and the return value both???
- pkt->finishTime = curTick + response_latency;
- return response_latency;
+ occupyLayer(now + clock);
+ }
}
-/** Function called by the port when the bus is receiving a Functional
- * transaction.*/
+template <typename PortClass>
void
-Bus::recvFunctional(PacketPtr pkt)
+BaseBus::Layer<PortClass>::recvRetry()
{
- DPRINTF(Bus, "recvFunctional: packet src %d dest %d addr 0x%x cmd %s\n",
- pkt->getSrc(), pkt->getDest(), pkt->getAddr(), pkt->cmdString());
- assert(pkt->getDest() == Packet::Broadcast);
-
- int port_id = findPort(pkt->getAddr());
- Port *port = interfaces[port_id];
- functionalSnoop(pkt, port);
+ // we got a retry from a peer that we tried to send something to
+ // and failed, but we sent it on the account of someone else, and
+ // that source port should be on our retry list, however if the
+ // bus layer is released before this happens and the retry (from
+ // the bus point of view) is successful then this no longer holds
+ // and we could in fact have an empty retry list
+ if (retryList.empty())
+ return;
- // If the snooping hasn't found what we were looking for, keep going.
- if (!pkt->isResponse() && port_id != pkt->getSrc()) {
- port->sendFunctional(pkt);
+ // if the bus layer is idle
+ if (state == IDLE) {
+ // note that we do not care who told us to retry at the moment, we
+ // merely let the first one on the retry list go
+ retryWaiting();
}
}
-/** Function called by the port when the bus is receiving a status change.*/
-void
-Bus::recvStatusChange(Port::Status status, int id)
+PortID
+BaseBus::findPort(Addr addr)
{
- AddrRangeList ranges;
- bool snoops;
- AddrRangeIter iter;
-
- assert(status == Port::RangeChange &&
- "The other statuses need to be implemented.");
-
- DPRINTF(BusAddrRanges, "received RangeChange from device id %d\n", id);
-
- if (id == defaultId) {
- defaultRange.clear();
- // Only try to update these ranges if the user set a default responder.
- if (responderSet) {
- defaultPort->getPeerAddressRanges(ranges, snoops);
- assert(snoops == false);
- for(iter = ranges.begin(); iter != ranges.end(); iter++) {
- defaultRange.push_back(*iter);
- DPRINTF(BusAddrRanges, "Adding range %#llx - %#llx for default range\n",
- iter->start, iter->end);
- }
+ // we should never see any address lookups before we've got the
+ // ranges of all connected slave modules
+ assert(gotAllAddrRanges);
+
+ // Check the cache
+ PortID dest_id = checkPortCache(addr);
+ if (dest_id != InvalidPortID)
+ return dest_id;
+
+ // Check the address map interval tree
+ PortMapConstIter i = portMap.find(addr);
+ if (i != portMap.end()) {
+ dest_id = i->second;
+ updatePortCache(dest_id, i->first);
+ return dest_id;
+ }
+
+ // Check if this matches the default range
+ if (useDefaultRange) {
+ if (defaultRange.contains(addr)) {
+ DPRINTF(BusAddrRanges, " found addr %#llx on default\n",
+ addr);
+ return defaultPortID;
}
- } else {
+ } else if (defaultPortID != InvalidPortID) {
+ DPRINTF(BusAddrRanges, "Unable to find destination for addr %#llx, "
+ "will use default port\n", addr);
+ return defaultPortID;
+ }
- assert((id < maxId && id >= 0) || id == defaultId);
- BusPort *port = interfaces[id];
+ // we should use the range for the default port and it did not
+ // match, or the default port is not set
+ fatal("Unable to find destination for addr %#llx on bus %s\n", addr,
+ name());
+}
- // Clean out any previously existent ids
- for (PortIter portIter = portMap.begin();
- portIter != portMap.end(); ) {
- if (portIter->second == id)
- portMap.erase(portIter++);
- else
- portIter++;
+/** Function called by the port when the bus is receiving a range change.*/
+void
+BaseBus::recvRangeChange(PortID master_port_id)
+{
+ DPRINTF(BusAddrRanges, "Received range change from slave port %s\n",
+ masterPorts[master_port_id]->getSlavePort().name());
+
+ // remember that we got a range from this master port and thus the
+ // connected slave module
+ gotAddrRanges[master_port_id] = true;
+
+ // update the global flag
+ if (!gotAllAddrRanges) {
+ // take a logical AND of all the ports and see if we got
+ // ranges from everyone
+ gotAllAddrRanges = true;
+ std::vector<bool>::const_iterator r = gotAddrRanges.begin();
+ while (gotAllAddrRanges && r != gotAddrRanges.end()) {
+ gotAllAddrRanges &= *r++;
}
+ if (gotAllAddrRanges)
+ DPRINTF(BusAddrRanges, "Got address ranges from all slaves\n");
+ }
- for (SnoopIter s_iter = snoopPorts.begin();
- s_iter != snoopPorts.end(); ) {
- if ((*s_iter)->getId() == id)
- s_iter = snoopPorts.erase(s_iter);
- else
- s_iter++;
+ // note that we could get the range from the default port at any
+ // point in time, and we cannot assume that the default range is
+ // set before the other ones are, so we do additional checks once
+ // all ranges are provided
+ if (master_port_id == defaultPortID) {
+ // only update if we are indeed checking ranges for the
+ // default port since the port might not have a valid range
+ // otherwise
+ if (useDefaultRange) {
+ AddrRangeList ranges = masterPorts[master_port_id]->getAddrRanges();
+
+ if (ranges.size() != 1)
+ fatal("Bus %s may only have a single default range",
+ name());
+
+ defaultRange = ranges.front();
}
-
- port->getPeerAddressRanges(ranges, snoops);
-
- if (snoops) {
- DPRINTF(BusAddrRanges, "Adding id %d to snoop list\n", id);
- snoopPorts.push_back(port);
+ } else {
+ // the ports are allowed to update their address ranges
+ // dynamically, so remove any existing entries
+ if (gotAddrRanges[master_port_id]) {
+ for (PortMapIter p = portMap.begin(); p != portMap.end(); ) {
+ if (p->second == master_port_id)
+ // erasing invalidates the iterator, so advance it
+ // before the deletion takes place
+ portMap.erase(p++);
+ else
+ p++;
+ }
}
- for (iter = ranges.begin(); iter != ranges.end(); iter++) {
- DPRINTF(BusAddrRanges, "Adding range %#llx - %#llx for id %d\n",
- iter->start, iter->end, id);
- if (portMap.insert(*iter, id) == portMap.end())
- panic("Two devices with same range\n");
-
+ AddrRangeList ranges = masterPorts[master_port_id]->getAddrRanges();
+
+ for (AddrRangeConstIter r = ranges.begin(); r != ranges.end(); ++r) {
+ DPRINTF(BusAddrRanges, "Adding range %s for id %d\n",
+ r->to_string(), master_port_id);
+ if (portMap.insert(*r, master_port_id) == portMap.end()) {
+ PortID conflict_id = portMap.find(*r)->second;
+ fatal("%s has two ports with same range:\n\t%s\n\t%s\n",
+ name(),
+ masterPorts[master_port_id]->getSlavePort().name(),
+ masterPorts[conflict_id]->getSlavePort().name());
+ }
}
}
- DPRINTF(MMU, "port list has %d entries\n", portMap.size());
- // tell all our peers that our address range has changed.
- // Don't tell the device that caused this change, it already knows
- m5::hash_map<short,BusPort*>::iterator intIter;
+ // if we have received ranges from all our neighbouring slave
+ // modules, go ahead and tell our connected master modules in
+ // turn, this effectively assumes a tree structure of the system
+ if (gotAllAddrRanges) {
+ // also check that no range partially overlaps with the
+ // default range, this has to be done after all ranges are set
+ // as there are no guarantees for when the default range is
+ // update with respect to the other ones
+ if (useDefaultRange) {
+ for (PortID port_id = 0; port_id < masterPorts.size(); ++port_id) {
+ if (port_id == defaultPortID) {
+ if (!gotAddrRanges[port_id])
+ fatal("Bus %s uses default range, but none provided",
+ name());
+ } else {
+ AddrRangeList ranges =
+ masterPorts[port_id]->getAddrRanges();
+
+ for (AddrRangeConstIter r = ranges.begin();
+ r != ranges.end(); ++r) {
+ // see if the new range is partially
+ // overlapping the default range
+ if (r->intersects(defaultRange) &&
+ !r->isSubset(defaultRange))
+ fatal("Range %s intersects the " \
+ "default range of %s but is not a " \
+ "subset\n", r->to_string(), name());
+ }
+ }
+ }
+ }
- for (intIter = interfaces.begin(); intIter != interfaces.end(); intIter++)
- if (intIter->first != id && intIter->first != funcPortId)
- intIter->second->sendStatusChange(Port::RangeChange);
+ // tell all our neighbouring master ports that our address
+ // ranges have changed
+ for (SlavePortConstIter s = slavePorts.begin(); s != slavePorts.end();
+ ++s)
+ (*s)->sendRangeChange();
+ }
- if (id != defaultId && defaultPort)
- defaultPort->sendStatusChange(Port::RangeChange);
+ clearPortCache();
}
-void
-Bus::addressRanges(AddrRangeList &resp, bool &snoop, int id)
+AddrRangeList
+BaseBus::getAddrRanges() const
{
- resp.clear();
- snoop = false;
+ // we should never be asked without first having sent a range
+ // change, and the latter is only done once we have all the ranges
+ // of the connected devices
+ assert(gotAllAddrRanges);
- DPRINTF(BusAddrRanges, "received address range request, returning:\n");
+ // at the moment, this never happens, as there are no cycles in
+ // the range queries and no devices on the master side of a bus
+ // (CPU, cache, bridge etc) actually care about the ranges of the
+ // ports they are connected to
- for (AddrRangeIter dflt_iter = defaultRange.begin();
- dflt_iter != defaultRange.end(); dflt_iter++) {
- resp.push_back(*dflt_iter);
- DPRINTF(BusAddrRanges, " -- Dflt: %#llx : %#llx\n",dflt_iter->start,
- dflt_iter->end);
- }
- for (PortIter portIter = portMap.begin();
- portIter != portMap.end(); portIter++) {
- bool subset = false;
- for (AddrRangeIter dflt_iter = defaultRange.begin();
- dflt_iter != defaultRange.end(); dflt_iter++) {
- if ((portIter->first.start < dflt_iter->start &&
- portIter->first.end >= dflt_iter->start) ||
- (portIter->first.start < dflt_iter->end &&
- portIter->first.end >= dflt_iter->end))
- fatal("Devices can not set ranges that itersect the default set\
- but are not a subset of the default set.\n");
- if (portIter->first.start >= dflt_iter->start &&
- portIter->first.end <= dflt_iter->end) {
- subset = true;
- DPRINTF(BusAddrRanges, " -- %#llx : %#llx is a SUBSET\n",
- portIter->first.start, portIter->first.end);
- }
- }
- if (portIter->second != id && !subset) {
- resp.push_back(portIter->first);
- DPRINTF(BusAddrRanges, " -- %#llx : %#llx\n",
- portIter->first.start, portIter->first.end);
- }
+ DPRINTF(BusAddrRanges, "Received address range request, returning:\n");
+
+ // start out with the default range
+ AddrRangeList ranges;
+ if (useDefaultRange) {
+ ranges.push_back(defaultRange);
+ DPRINTF(BusAddrRanges, " -- Default %s\n", defaultRange.to_string());
}
- for (SnoopIter s_iter = snoopPorts.begin(); s_iter != snoopPorts.end();
- s_iter++) {
- if ((*s_iter)->getId() != id) {
- snoop = true;
- break;
+ // add any range that is not a subset of the default range
+ for (PortMapConstIter p = portMap.begin(); p != portMap.end(); ++p) {
+ if (useDefaultRange && p->first.isSubset(defaultRange)) {
+ DPRINTF(BusAddrRanges, " -- %s is a subset of default\n",
+ p->first.to_string());
+ } else {
+ ranges.push_back(p->first);
+ DPRINTF(BusAddrRanges, " -- %s\n", p->first.to_string());
}
}
+
+ return ranges;
}
-int
-Bus::findBlockSize(int id)
+unsigned
+BaseBus::deviceBlockSize() const
{
- if (cachedBlockSizeValid)
- return cachedBlockSize;
-
- int max_bs = -1;
-
- for (PortIter portIter = portMap.begin();
- portIter != portMap.end(); portIter++) {
- int tmp_bs = interfaces[portIter->second]->peerBlockSize();
- if (tmp_bs > max_bs)
- max_bs = tmp_bs;
- }
- for (SnoopIter s_iter = snoopPorts.begin();
- s_iter != snoopPorts.end(); s_iter++) {
- int tmp_bs = (*s_iter)->peerBlockSize();
- if (tmp_bs > max_bs)
- max_bs = tmp_bs;
- }
- if (max_bs <= 0)
- max_bs = defaultBlockSize;
-
- if (max_bs != 64)
- warn_once("Blocksize found to not be 64... hmm... probably not.\n");
- cachedBlockSize = max_bs;
- cachedBlockSizeValid = true;
- return max_bs;
+ return blockSize;
}
-
+template <typename PortClass>
unsigned int
-Bus::drain(Event * de)
+BaseBus::Layer<PortClass>::drain(DrainManager *dm)
{
//We should check that we're not "doing" anything, and that noone is
//waiting. We might be idle but have someone waiting if the device we
//contacted for a retry didn't actually retry.
- if (curTick >= tickNextIdle && retryList.size() == 0) {
- return 0;
- } else {
- drainEvent = de;
+ if (!retryList.empty() || state != IDLE) {
+ DPRINTF(Drain, "Bus not drained\n");
+ drainManager = dm;
return 1;
}
+ return 0;
}
-void
-Bus::startup()
-{
- if (tickNextIdle < curTick)
- tickNextIdle = (curTick / clock) * clock + clock;
-}
-
-BEGIN_DECLARE_SIM_OBJECT_PARAMS(Bus)
-
- Param<int> bus_id;
- Param<int> clock;
- Param<int> width;
- Param<bool> responder_set;
- Param<int> block_size;
-
-END_DECLARE_SIM_OBJECT_PARAMS(Bus)
-
-BEGIN_INIT_SIM_OBJECT_PARAMS(Bus)
- INIT_PARAM(bus_id, "a globally unique bus id"),
- INIT_PARAM(clock, "bus clock speed"),
- INIT_PARAM(width, "width of the bus (bits)"),
- INIT_PARAM(responder_set, "Is a default responder set by the user"),
- INIT_PARAM(block_size, "Default blocksize if no device has one")
-END_INIT_SIM_OBJECT_PARAMS(Bus)
-
-CREATE_SIM_OBJECT(Bus)
-{
- return new Bus(getInstanceName(), bus_id, clock, width, responder_set,
- block_size);
-}
-
-REGISTER_SIM_OBJECT("Bus", Bus)
+/**
+ * Bus layer template instantiations. Could be removed with _impl.hh
+ * file, but since there are only two given options (MasterPort and
+ * SlavePort) it seems a bit excessive at this point.
+ */
+template class BaseBus::Layer<SlavePort>;
+template class BaseBus::Layer<MasterPort>;