X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fmem%2Fbus.cc;h=d29422593214fd3971b8a5c6410988c1afa0a459;hb=8573a69d8f7bf7b3f074e3e0ac64994801c551be;hp=e37449b6e2b56271ed4938c6e0eda1b07d8fd80e;hpb=ef4af8cec8b1826abff5b92b9fec32f7c2818372;p=gem5.git diff --git a/src/mem/bus.cc b/src/mem/bus.cc index e37449b6e..d29422593 100644 --- a/src/mem/bus.cc +++ b/src/mem/bus.cc @@ -1,5 +1,5 @@ /* - * 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 @@ -39,6 +39,7 @@ * * Authors: Ali Saidi * Andreas Hansson + * William Wang */ /** @@ -50,282 +51,315 @@ #include "base/trace.hh" #include "debug/Bus.hh" #include "debug/BusAddrRanges.hh" -#include "debug/MMU.hh" +#include "debug/Drain.hh" #include "mem/bus.hh" -Bus::Bus(const BusParams *p) - : MemObject(p), busId(p->bus_id), clock(p->clock), - headerCycles(p->header_cycles), width(p->width), tickNextIdle(0), - drainEvent(NULL), busIdle(this), inRetry(false), - defaultPortId(INVALID_PORT_ID), useDefaultRange(p->use_default_range), - defaultBlockSize(p->block_size), - cachedBlockSize(0), cachedBlockSizeValid(false) +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() { - //width, clock period, and header cycles must be positive - if (width <= 0) - fatal("Bus width must be positive\n"); - if (clock <= 0) - fatal("Bus clock period must be positive\n"); - if (headerCycles <= 0) - fatal("Number of header cycles must be positive\n"); - clearPortCache(); + for (MasterPortIter m = masterPorts.begin(); m != masterPorts.end(); + ++m) { + delete *m; + } + + for (SlavePortIter s = slavePorts.begin(); s != slavePorts.end(); + ++s) { + delete *s; + } } -Port * -Bus::getPort(const std::string &if_name, int idx) +void +BaseBus::init() { - std::string portName; - int id = interfaces.size(); - if (if_name == "default") { - if (defaultPortId == INVALID_PORT_ID) { - defaultPortId = id; - portName = csprintf("%s-default", name()); - } else - fatal("Default port already set on %s\n", name()); - } else { - portName = csprintf("%s-p%d", name(), id); + // determine the maximum peer block size, look at both the + // connected master and slave modules + uint32_t peer_block_size = 0; + + for (MasterPortConstIter m = masterPorts.begin(); m != masterPorts.end(); + ++m) { + peer_block_size = std::max((*m)->peerBlockSize(), peer_block_size); + } + + for (SlavePortConstIter s = slavePorts.begin(); s != slavePorts.end(); + ++s) { + peer_block_size = std::max((*s)->peerBlockSize(), peer_block_size); } - BusPort *bp = new BusPort(portName, this, id); - interfaces.push_back(bp); - cachedBlockSizeValid = false; - return bp; + + // 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; + + // 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::init() +BaseMasterPort & +BaseBus::getMasterPort(const std::string &if_name, PortID idx) { - std::vector::iterator intIter; - - // iterate over our interfaces and determine which of our neighbours - // are snooping and add them as snoopers - for (intIter = interfaces.begin(); intIter != interfaces.end(); - intIter++) { - if ((*intIter)->getPeer()->isSnooping()) { - DPRINTF(BusAddrRanges, "Adding snooping neighbour %s\n", - (*intIter)->getPeer()->name()); - snoopPorts.push_back(*intIter); - } + 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); } } -Bus::BusFreeEvent::BusFreeEvent(Bus *_bus) - : bus(_bus) -{} +BaseSlavePort & +BaseBus::getSlavePort(const std::string &if_name, PortID idx) +{ + 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::BusFreeEvent::process() +BaseBus::calcPacketTiming(PacketPtr pkt) { - bus->recvRetry(-1); + // the bus will be called at a time that is not necessarily + // coinciding with its own clock, so start by determining how long + // until the next clock edge (could be zero) + Tick offset = nextCycle() - curTick(); + + // determine how many cycles are needed to send the data + unsigned dataCycles = pkt->hasData() ? divCeil(pkt->getSize(), width) : 0; + + // before setting the bus delay fields of the packet, ensure that + // the delay from any previous bus has been accounted for + if (pkt->busFirstWordDelay != 0 || pkt->busLastWordDelay != 0) + panic("Packet %s already has bus delay (%d, %d) that should be " + "accounted for.\n", pkt->cmdString(), pkt->busFirstWordDelay, + pkt->busLastWordDelay); + + // The first word will be delivered on the cycle after the header. + pkt->busFirstWordDelay = (headerCycles + 1) * clockPeriod() + offset; + + // Note that currently busLastWordDelay can be smaller than + // busFirstWordDelay if the packet has no data + pkt->busLastWordDelay = (headerCycles + dataCycles) * clockPeriod() + + offset; } -const char * -Bus::BusFreeEvent::description() const +template +BaseBus::Layer::Layer(BaseBus& _bus, const std::string& _name) : + Drainable(), + bus(_bus), _name(_name), state(IDLE), drainManager(NULL), + releaseEvent(this) { - return "bus became available"; } -Tick -Bus::calcPacketTiming(PacketPtr pkt) +template +void BaseBus::Layer::occupyLayer(Tick until) { - // 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; - } + // 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); +} - Tick headerTime = tickNextIdle + 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; - if (pkt->hasData()) { - // If a packet has data, it needs ceil(size/width) cycles to send it - int dataSize = pkt->getSize(); - numCycles += dataSize/width; - if (dataSize % width) - numCycles++; +template +bool +BaseBus::Layer::tryTiming(PortClass* port) +{ + // 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; } - // 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 = headerTime + clock; + // 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; - pkt->finishTime = headerTime + numCycles * clock; - - return headerTime; + return true; } -void Bus::occupyBus(Tick until) +template +void +BaseBus::Layer::succeededTiming(Tick busy_time) { - if (until == 0) { - // shortcut for express snoop packets - return; + // 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; } - tickNextIdle = until; - reschedule(busIdle, tickNextIdle, 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); - DPRINTF(Bus, "The bus is now occupied from tick %d to %d\n", - curTick(), tickNextIdle); + // occupy the bus accordingly + occupyLayer(busy_time); } -/** Function called by the port when the bus is receiving a Timing - * transaction.*/ -bool -Bus::recvTiming(PacketPtr pkt) +template +void +BaseBus::Layer::failedTiming(PortClass* port, Tick busy_time) { - short src = pkt->getSrc(); - - BusPort *src_port = interfaces[src]; - - // 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->isExpressSnoop() && - (tickNextIdle > curTick() || - (retryList.size() && (!inRetry || src_port != retryList.front())))) - { - addToRetryList(src_port); - DPRINTF(Bus, "recvTiming: src %d dst %d %s 0x%x BUSY\n", - src, pkt->getDest(), pkt->cmdString(), pkt->getAddr()); - return false; + // 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); } - DPRINTF(Bus, "recvTiming: src %d dst %d %s 0x%x\n", - src, pkt->getDest(), pkt->cmdString(), pkt->getAddr()); - - Tick headerFinishTime = pkt->isExpressSnoop() ? 0 : calcPacketTiming(pkt); - Tick packetFinishTime = pkt->isExpressSnoop() ? 0 : pkt->finishTime; - - short dest = pkt->getDest(); - int dest_port_id; - Port *dest_port; - - if (dest == Packet::Broadcast) { - dest_port_id = findPort(pkt->getAddr()); - dest_port = interfaces[dest_port_id]; - SnoopIter s_end = snoopPorts.end(); - for (SnoopIter s_iter = snoopPorts.begin(); s_iter != s_end; s_iter++) { - BusPort *p = *s_iter; - if (p != dest_port && p != src_port) { - // cache is not allowed to refuse snoop - bool success M5_VAR_USED = p->sendTiming(pkt); - assert(success); - } - } - } else { - assert(dest < interfaces.size()); - assert(dest != src); // catch infinite loops - dest_port_id = dest; - dest_port = interfaces[dest_port_id]; - } + // even if we retried the current one and did not succeed, + // we are no longer retrying but instead busy + state = BUSY; - if (dest_port_id == src) { - // Must be forwarded snoop up from below... - assert(dest == Packet::Broadcast); - } else { - // send to actual target - if (!dest_port->sendTiming(pkt)) { - // Packet not successfully sent. Leave or put it on the retry list. - // illegal to block responses... can lead to deadlock - assert(!pkt->isResponse()); - // It's also illegal to force a transaction to retry after - // someone else has committed to respond. - assert(!pkt->memInhibitAsserted()); - DPRINTF(Bus, "recvTiming: src %d dst %d %s 0x%x TGT RETRY\n", - src, pkt->getDest(), pkt->cmdString(), pkt->getAddr()); - addToRetryList(src_port); - occupyBus(headerFinishTime); - return false; - } - // send OK, fall through... pkt may have been deleted by - // target at this point, so it should *not* be referenced - // again. We'll set it to NULL here just to be safe. - pkt = NULL; + // occupy the bus accordingly + occupyLayer(busy_time); +} + +template +void +BaseBus::Layer::releaseLayer() +{ + // 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; } +} - occupyBus(packetFinishTime); +template +void +BaseBus::Layer::retryWaiting() +{ + // this should never be called with an empty retry list + assert(!retryList.empty()); - // Packet was successfully sent. - // Also take care of retries - if (inRetry) { - DPRINTF(Bus, "Remove retry from list %d\n", src); + // we always go to retrying from idle + assert(state == IDLE); + + // update the state which is shared for request, response and + // snoop responses + state = RETRY; + + // 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(); + + // 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(); - inRetry = false; + + //Burn a cycle for the missed grant. + + // update the state which is shared for request, response and + // snoop responses + state = BUSY; + + // occupy the bus layer until the next cycle ends + occupyLayer(bus.clockEdge(Cycles(1))); } - return true; } +template void -Bus::recvRetry(int id) +BaseBus::Layer::recvRetry() { - // 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.pop_front(); - inRetry = false; - - //Bring tickNextIdle up to the present - while (tickNextIdle < curTick()) - tickNextIdle += clock; - - //Burn a cycle for the missed grant. - tickNextIdle += clock; - - reschedule(busIdle, 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; + // 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 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(); } } -int -Bus::findPort(Addr addr) +PortID +BaseBus::findPort(Addr addr) { - /* An interval tree would be a better way to do this. --ali. */ - int dest_id; + // we should never see any address lookups before we've got the + // ranges of all connected slave modules + assert(gotAllAddrRanges); - dest_id = checkPortCache(addr); - if (dest_id != INVALID_PORT_ID) + // Check the cache + PortID dest_id = checkPortCache(addr); + if (dest_id != InvalidPortID) return dest_id; - // Check normal port ranges - PortIter i = portMap.find(RangeSize(addr,1)); + // Check the address map interval tree + PortMapConstIter i = portMap.find(addr); if (i != portMap.end()) { dest_id = i->second; - updatePortCache(dest_id, i->first.start, i->first.end); + updatePortCache(dest_id, i->first); return dest_id; } // Check if this matches the default range if (useDefaultRange) { - AddrRangeIter a_end = defaultRange.end(); - for (AddrRangeIter i = defaultRange.begin(); i != a_end; i++) { - if (*i == addr) { - DPRINTF(Bus, " found addr %#llx on default\n", addr); - return defaultPortId; - } + if (defaultRange.contains(addr)) { + DPRINTF(BusAddrRanges, " found addr %#llx on default\n", + addr); + return defaultPortID; } - } else if (defaultPortId != INVALID_PORT_ID) { - DPRINTF(Bus, "Unable to find destination for addr %#llx, " + } else if (defaultPortID != InvalidPortID) { + DPRINTF(BusAddrRanges, "Unable to find destination for addr %#llx, " "will use default port\n", addr); - return defaultPortId; + return defaultPortID; } // we should use the range for the default port and it did not @@ -334,292 +368,213 @@ Bus::findPort(Addr addr) name()); } - -/** Function called by the port when the bus is receiving a Atomic - * transaction.*/ -Tick -Bus::recvAtomic(PacketPtr pkt) +/** Function called by the port when the bus is receiving a range change.*/ +void +BaseBus::recvRangeChange(PortID master_port_id) { - 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()); - BusPort *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); - } + 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::const_iterator r = gotAddrRanges.begin(); + while (gotAllAddrRanges && r != gotAddrRanges.end()) { + gotAllAddrRanges &= *r++; } + if (gotAllAddrRanges) + DPRINTF(BusAddrRanges, "Got address ranges from all slaves\n"); } - Tick response_latency = 0; - - // 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); - } - - // 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; - } - - // why do we have this packet field and the return value both??? - pkt->finishTime = curTick() + response_latency; - return response_latency; -} - -/** Function called by the port when the bus is receiving a Functional - * transaction.*/ -void -Bus::recvFunctional(PacketPtr pkt) -{ - assert(pkt->getDest() == Packet::Broadcast); - - int port_id = findPort(pkt->getAddr()); - Port *port = interfaces[port_id]; - // The packet may be changed by another bus on snoops, restore the - // id after each - int src_id = pkt->getSrc(); - - if (!pkt->isPrint()) { - // don't do DPRINTFs on PrintReq as it clutters up the output - DPRINTF(Bus, - "recvFunctional: packet src %d dest %d addr 0x%x cmd %s\n", - src_id, port_id, pkt->getAddr(), - pkt->cmdString()); - } + // 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(); - assert(pkt->isRequest()); // hasn't already been satisfied + if (ranges.size() != 1) + fatal("Bus %s may only have a single default range", + name()); - SnoopIter s_end = snoopPorts.end(); - for (SnoopIter s_iter = snoopPorts.begin(); s_iter != s_end; s_iter++) { - BusPort *p = *s_iter; - if (p != port && p->getId() != src_id) { - p->sendFunctional(pkt); + defaultRange = ranges.front(); } - if (pkt->isResponse()) { - break; + } 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++; + } } - pkt->setSrc(src_id); - } - // If the snooping hasn't found what we were looking for and it is not - // a forwarded snoop from below, keep going. - if (!pkt->isResponse() && port_id != pkt->getSrc()) { - port->sendFunctional(pkt); + 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()); + } + } } -} -/** Function called by the port when the bus is receiving a range change.*/ -void -Bus::recvRangeChange(int id) -{ - AddrRangeList ranges; - AddrRangeIter iter; + // 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) { + DPRINTF(BusAddrRanges, "Aggregating bus ranges\n"); + busRanges.clear(); - if (inRecvRangeChange.count(id)) - return; - inRecvRangeChange.insert(id); + // start out with the default range + if (useDefaultRange) { + if (!gotAddrRanges[defaultPortID]) + fatal("Bus %s uses default range, but none provided", + name()); - DPRINTF(BusAddrRanges, "received RangeChange from device id %d\n", id); + busRanges.push_back(defaultRange); + DPRINTF(BusAddrRanges, "-- Adding default %s\n", + defaultRange.to_string()); + } - clearPortCache(); - if (id == defaultPortId) { - defaultRange.clear(); - // Only try to update these ranges if the user set a default responder. - if (useDefaultRange) { - AddrRangeList ranges = interfaces[id]->getPeer()->getAddrRanges(); - 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); + // merge all interleaved ranges and add any range that is not + // a subset of the default range + std::vector intlv_ranges; + for (AddrRangeMap::const_iterator r = portMap.begin(); + r != portMap.end(); ++r) { + // if the range is interleaved then save it for now + if (r->first.interleaved()) { + // if we already got interleaved ranges that are not + // part of the same range, then first do a merge + // before we add the new one + if (!intlv_ranges.empty() && + !intlv_ranges.back().mergesWith(r->first)) { + DPRINTF(BusAddrRanges, "-- Merging range from %d ranges\n", + intlv_ranges.size()); + AddrRange merged_range(intlv_ranges); + // next decide if we keep the merged range or not + if (!(useDefaultRange && + merged_range.isSubset(defaultRange))) { + busRanges.push_back(merged_range); + DPRINTF(BusAddrRanges, "-- Adding merged range %s\n", + merged_range.to_string()); + } + intlv_ranges.clear(); + } + intlv_ranges.push_back(r->first); + } else { + // keep the current range if not a subset of the default + if (!(useDefaultRange && + r->first.isSubset(defaultRange))) { + busRanges.push_back(r->first); + DPRINTF(BusAddrRanges, "-- Adding range %s\n", + r->first.to_string()); + } } } - } else { - assert(id < interfaces.size() && id >= 0); - BusPort *port = interfaces[id]; - - // Clean out any previously existent ids - for (PortIter portIter = portMap.begin(); - portIter != portMap.end(); ) { - if (portIter->second == id) - portMap.erase(portIter++); - else - portIter++; + // if there is still interleaved ranges waiting to be merged, + // go ahead and do it + if (!intlv_ranges.empty()) { + DPRINTF(BusAddrRanges, "-- Merging range from %d ranges\n", + intlv_ranges.size()); + AddrRange merged_range(intlv_ranges); + if (!(useDefaultRange && merged_range.isSubset(defaultRange))) { + busRanges.push_back(merged_range); + DPRINTF(BusAddrRanges, "-- Adding merged range %s\n", + merged_range.to_string()); + } } - ranges = port->getPeer()->getAddrRanges(); - - 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()) { - int conflict_id = portMap.find(*iter)->second; - fatal("%s has two ports with same range:\n\t%s\n\t%s\n", - name(), interfaces[id]->getPeer()->name(), - interfaces[conflict_id]->getPeer()->name()); + // 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 (AddrRangeConstIter r = busRanges.begin(); + r != busRanges.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()); } } - } - 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 - std::vector::const_iterator intIter; - - for (intIter = interfaces.begin(); intIter != interfaces.end(); intIter++) - if ((*intIter)->getId() != id) - (*intIter)->sendRangeChange(); + // tell all our neighbouring master ports that our address + // ranges have changed + for (SlavePortConstIter s = slavePorts.begin(); s != slavePorts.end(); + ++s) + (*s)->sendRangeChange(); + } - inRecvRangeChange.erase(id); + clearPortCache(); } AddrRangeList -Bus::getAddrRanges(int id) +BaseBus::getAddrRanges() const { - AddrRangeList ranges; + // 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++) { - ranges.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) { - ranges.push_back(portIter->first); - DPRINTF(BusAddrRanges, " -- %#llx : %#llx\n", - portIter->first.start, portIter->first.end); - } - } + DPRINTF(BusAddrRanges, "Received address range request\n"); - return ranges; -} - -bool -Bus::isSnooping(int id) -{ - // in essence, answer the question if there are other snooping - // ports rather than the port that is asking - bool snoop = false; - for (SnoopIter s_iter = snoopPorts.begin(); s_iter != snoopPorts.end(); - s_iter++) { - if ((*s_iter)->getId() != id) { - snoop = true; - break; - } - } - return snoop; + return busRanges; } unsigned -Bus::findBlockSize(int id) +BaseBus::deviceBlockSize() const { - if (cachedBlockSizeValid) - return cachedBlockSize; - - unsigned max_bs = 0; - - PortIter p_end = portMap.end(); - for (PortIter p_iter = portMap.begin(); p_iter != p_end; p_iter++) { - unsigned tmp_bs = interfaces[p_iter->second]->peerBlockSize(); - if (tmp_bs > max_bs) - max_bs = tmp_bs; - } - SnoopIter s_end = snoopPorts.end(); - for (SnoopIter s_iter = snoopPorts.begin(); s_iter != s_end; s_iter++) { - unsigned 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 unsigned int -Bus::drain(Event * de) +BaseBus::Layer::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 (retryList.size() || (curTick() < tickNextIdle && busIdle.scheduled())) { - 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; -} - -Bus * -BusParams::create() -{ - return new Bus(this); -} +/** + * 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; +template class BaseBus::Layer;