X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fmem%2Fbus.cc;h=829d694de3bfdfff1cb41c5c5b2e688f2f9d1526;hb=287ea1a081c5dd3213069755dbbd3d7bf736bacc;hp=e24b54b0e1ed2494142c83d808329edaf73dca07;hpb=cad802761a876c6dcd00d58e09c8984886c987f6;p=gem5.git diff --git a/src/mem/bus.cc b/src/mem/bus.cc index e24b54b0e..829d694de 100644 --- a/src/mem/bus.cc +++ b/src/mem/bus.cc @@ -51,12 +51,12 @@ #include "base/trace.hh" #include "debug/Bus.hh" #include "debug/BusAddrRanges.hh" +#include "debug/Drain.hh" #include "mem/bus.hh" -Bus::Bus(const BusParams *p) - : MemObject(p), clock(p->clock), - headerCycles(p->header_cycles), width(p->width), tickNextIdle(0), - drainEvent(NULL), busIdleEvent(this), inRetry(false), +BaseBus::BaseBus(const BaseBusParams *p) + : MemObject(p), + headerCycles(p->header_cycles), width(p->width), defaultPortID(InvalidPortID), useDefaultRange(p->use_default_range), defaultBlockSize(p->block_size), @@ -69,37 +69,23 @@ Bus::Bus(const BusParams *p) fatal("Bus clock period must be positive\n"); if (headerCycles <= 0) fatal("Number of header cycles must be positive\n"); +} - // create the ports based on the size of the master and slave - // vector ports, and the presence of the default port, the ports - // are enumerated starting from zero - for (int i = 0; i < p->port_master_connection_count; ++i) { - std::string portName = csprintf("%s-p%d", name(), i); - MasterPort* bp = new BusMasterPort(portName, this, i); - masterPorts.push_back(bp); - } - - // see if we have a default slave device connected and if so add - // our corresponding master port - if (p->port_default_connection_count) { - defaultPortID = masterPorts.size(); - std::string portName = csprintf("%s-default", name()); - MasterPort* bp = new BusMasterPort(portName, this, defaultPortID); - masterPorts.push_back(bp); +BaseBus::~BaseBus() +{ + for (MasterPortIter m = masterPorts.begin(); m != masterPorts.end(); + ++m) { + delete *m; } - // create the slave ports, once again starting at zero - for (int i = 0; i < p->port_slave_connection_count; ++i) { - std::string portName = csprintf("%s-p%d", name(), i); - SlavePort* bp = new BusSlavePort(portName, this, i); - slavePorts.push_back(bp); + for (SlavePortIter s = slavePorts.begin(); s != slavePorts.end(); + ++s) { + delete *s; } - - clearPortCache(); } MasterPort & -Bus::getMasterPort(const std::string &if_name, int idx) +BaseBus::getMasterPort(const std::string &if_name, int idx) { if (if_name == "master" && idx < masterPorts.size()) { // the master port index translates directly to the vector position @@ -112,7 +98,7 @@ Bus::getMasterPort(const std::string &if_name, int idx) } SlavePort & -Bus::getSlavePort(const std::string &if_name, int idx) +BaseBus::getSlavePort(const std::string &if_name, int idx) { if (if_name == "slave" && idx < slavePorts.size()) { // the slave port index translates directly to the vector position @@ -122,30 +108,12 @@ Bus::getSlavePort(const std::string &if_name, int idx) } } -void -Bus::init() -{ - // iterate over our slave ports and determine which of our - // neighbouring master ports are snooping and add them as snoopers - for (SlavePortConstIter p = slavePorts.begin(); p != slavePorts.end(); - ++p) { - if ((*p)->getMasterPort().isSnooping()) { - DPRINTF(BusAddrRanges, "Adding snooping neighbour %s\n", - (*p)->getMasterPort().name()); - snoopPorts.push_back(*p); - } - } -} - Tick -Bus::calcPacketTiming(PacketPtr pkt) +BaseBus::calcPacketTiming(PacketPtr pkt) { // determine the current time rounded to the closest following // clock edge - Tick now = curTick(); - if (now % clock != 0) { - now = ((now / clock) + 1) * clock; - } + Tick now = nextCycle(); Tick headerTime = now + headerCycles * clock; @@ -169,268 +137,106 @@ Bus::calcPacketTiming(PacketPtr pkt) return headerTime; } -void Bus::occupyBus(Tick until) +template +BaseBus::Layer::Layer(BaseBus& _bus, const std::string& _name, + Tick _clock) : + bus(_bus), _name(_name), state(IDLE), clock(_clock), drainEvent(NULL), + releaseEvent(this) { - if (until == 0) { - // shortcut for express snoop packets - return; - } - - tickNextIdle = until; - reschedule(busIdleEvent, tickNextIdle, true); - - DPRINTF(Bus, "The bus is now occupied from tick %d to %d\n", - curTick(), tickNextIdle); } -bool -Bus::isOccupied(PacketPtr pkt, Port* port) +template +void BaseBus::Layer::occupyLayer(Tick until) { - // first we see if the next idle tick is in the future, next the - // bus is considered occupied if there are ports on the retry list - // and we are not in a retry with the current port - if (tickNextIdle > curTick() || - (!retryList.empty() && !(inRetry && port == retryList.front()))) { - addToRetryList(port); - return true; - } - return false; + // 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 bool -Bus::recvTimingReq(PacketPtr pkt) +BaseBus::Layer::tryTiming(PortClass* port) { - // determine the source port based on the id - SlavePort *src_port = slavePorts[pkt->getSrc()]; - - // test if the bus should be considered occupied for the current - // packet, and exclude express snoops from the check - if (!pkt->isExpressSnoop() && isOccupied(pkt, src_port)) { - DPRINTF(Bus, "recvTimingReq: src %s %s 0x%x BUSY\n", - src_port->name(), pkt->cmdString(), pkt->getAddr()); + // 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; } - DPRINTF(Bus, "recvTimingReq: src %s %s 0x%x\n", - src_port->name(), pkt->cmdString(), pkt->getAddr()); - - Tick headerFinishTime = pkt->isExpressSnoop() ? 0 : calcPacketTiming(pkt); - Tick packetFinishTime = pkt->isExpressSnoop() ? 0 : pkt->finishTime; - - // uncacheable requests need never be snooped - if (!pkt->req->isUncacheable()) { - // the packet is a memory-mapped request and should be - // broadcasted to our snoopers but the source - forwardTiming(pkt, pkt->getSrc()); - } - - // remember if we add an outstanding req so we can undo it if - // necessary, if the packet needs a response, we should add it - // as outstanding and express snoops never fail so there is - // not need to worry about them - bool add_outstanding = !pkt->isExpressSnoop() && pkt->needsResponse(); - - // keep track that we have an outstanding request packet - // matching this request, this is used by the coherency - // mechanism in determining what to do with snoop responses - // (in recvTimingSnoop) - if (add_outstanding) { - // we should never have an exsiting request outstanding - assert(outstandingReq.find(pkt->req) == outstandingReq.end()); - outstandingReq.insert(pkt->req); - } - - // since it is a normal request, determine the destination - // based on the address and attempt to send the packet - bool success = masterPorts[findPort(pkt->getAddr())]->sendTimingReq(pkt); - - if (!success) { - // inhibited packets should never be forced to retry - assert(!pkt->memInhibitAsserted()); - - // if it was added as outstanding and the send failed, then - // erase it again - if (add_outstanding) - outstandingReq.erase(pkt->req); - - DPRINTF(Bus, "recvTimingReq: src %s %s 0x%x RETRY\n", - src_port->name(), pkt->cmdString(), pkt->getAddr()); - - addToRetryList(src_port); - occupyBus(headerFinishTime); - - return false; - } - - succeededTiming(packetFinishTime); + // 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; return true; } -bool -Bus::recvTimingResp(PacketPtr pkt) +template +void +BaseBus::Layer::succeededTiming(Tick busy_time) { - // determine the source port based on the id - MasterPort *src_port = masterPorts[pkt->getSrc()]; - - // test if the bus should be considered occupied for the current - // packet - if (isOccupied(pkt, src_port)) { - DPRINTF(Bus, "recvTimingResp: src %s %s 0x%x BUSY\n", - src_port->name(), pkt->cmdString(), pkt->getAddr()); - return false; + // 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; } - DPRINTF(Bus, "recvTimingResp: src %s %s 0x%x\n", - src_port->name(), pkt->cmdString(), pkt->getAddr()); - - calcPacketTiming(pkt); - Tick packetFinishTime = pkt->finishTime; - - // the packet is a normal response to a request that we should - // have seen passing through the bus - assert(outstandingReq.find(pkt->req) != outstandingReq.end()); + // we should either have gone from idle to busy in the + // tryTiming test, or just gone from a retry to busy + assert(state == BUSY); - // remove it as outstanding - outstandingReq.erase(pkt->req); - - // send the packet to the destination through one of our slave - // ports, as determined by the destination field - bool success M5_VAR_USED = slavePorts[pkt->getDest()]->sendTimingResp(pkt); - - // currently it is illegal to block responses... can lead to - // deadlock - assert(success); - - succeededTiming(packetFinishTime); - - return true; + // occupy the bus accordingly + occupyLayer(busy_time); } +template void -Bus::recvTimingSnoopReq(PacketPtr pkt) -{ - DPRINTF(Bus, "recvTimingSnoopReq: src %s %s 0x%x\n", - masterPorts[pkt->getSrc()]->name(), pkt->cmdString(), - pkt->getAddr()); - - // we should only see express snoops from caches - assert(pkt->isExpressSnoop()); - - // forward to all snoopers - forwardTiming(pkt, InvalidPortID); - - // a snoop request came from a connected slave device (one of - // our master ports), and if it is not coming from the slave - // device responsible for the address range something is - // wrong, hence there is nothing further to do as the packet - // would be going back to where it came from - assert(pkt->getSrc() == findPort(pkt->getAddr())); - - // this is an express snoop and is never forced to retry - assert(!inRetry); -} - -bool -Bus::recvTimingSnoopResp(PacketPtr pkt) +BaseBus::Layer::failedTiming(PortClass* port, Tick busy_time) { - // determine the source port based on the id - SlavePort* src_port = slavePorts[pkt->getSrc()]; - - if (isOccupied(pkt, src_port)) { - DPRINTF(Bus, "recvTimingSnoopResp: src %s %s 0x%x BUSY\n", - src_port->name(), pkt->cmdString(), pkt->getAddr()); - return false; - } - - DPRINTF(Bus, "recvTimingSnoop: src %s %s 0x%x\n", - src_port->name(), pkt->cmdString(), pkt->getAddr()); - - // get the destination from the packet - PortID dest = pkt->getDest(); - - // responses are never express snoops - assert(!pkt->isExpressSnoop()); - - calcPacketTiming(pkt); - Tick packetFinishTime = pkt->finishTime; - - // determine if the response is from a snoop request we - // created as the result of a normal request (in which case it - // should be in the outstandingReq), or if we merely forwarded - // someone else's snoop request - if (outstandingReq.find(pkt->req) == outstandingReq.end()) { - // this is a snoop response to a snoop request we - // forwarded, e.g. coming from the L1 and going to the L2 - // this should be forwarded as a snoop response - bool success M5_VAR_USED = masterPorts[dest]->sendTimingSnoopResp(pkt); - assert(success); - } else { - // we got a snoop response on one of our slave ports, - // i.e. from a coherent master connected to the bus, and - // since we created the snoop request as part of - // recvTiming, this should now be a normal response again - outstandingReq.erase(pkt->req); - - // this is a snoop response from a coherent master, with a - // destination field set on its way through the bus as - // request, hence it should never go back to where the - // snoop response came from, but instead to where the - // original request came from - assert(pkt->getSrc() != dest); - - // as a normal response, it should go back to a master - // through one of our slave ports - bool success M5_VAR_USED = slavePorts[dest]->sendTimingResp(pkt); - - // currently it is illegal to block responses... can lead - // to deadlock - assert(success); + // 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); } - succeededTiming(packetFinishTime); + // even if we retried the current one and did not succeed, + // we are no longer retrying but instead busy + state = BUSY; - return true; -} - - -void -Bus::succeededTiming(Tick busy_time) -{ // occupy the bus accordingly - occupyBus(busy_time); - - // if a retrying port succeeded, also take it off the retry list - if (inRetry) { - DPRINTF(Bus, "Remove retry from list %s\n", - retryList.front()->name()); - retryList.pop_front(); - inRetry = false; - } -} - -void -Bus::forwardTiming(PacketPtr pkt, PortID exclude_slave_port_id) -{ - for (SlavePortIter s = snoopPorts.begin(); s != snoopPorts.end(); ++s) { - SlavePort *p = *s; - // we could have gotten this request from a snooping master - // (corresponding to our own slave port that is also in - // snoopPorts) and should not send it back to where it came - // from - if (exclude_slave_port_id == InvalidPortID || - p->getId() != exclude_slave_port_id) { - // cache is not allowed to refuse snoop - p->sendTimingSnoopReq(pkt); - } - } + occupyLayer(busy_time); } +template void -Bus::releaseBus() +BaseBus::Layer::releaseLayer() { // releasing the bus means we should now be idle - assert(curTick() >= tickNextIdle); + 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()) { @@ -439,61 +245,68 @@ Bus::releaseBus() // busy, and in the latter case the bus may be released before // we see a retry from the destination retryWaiting(); - } - - //If we weren't able to drain before, we might be able to now. - if (drainEvent && retryList.empty() && curTick() >= tickNextIdle) { + } else if (drainEvent) { + DPRINTF(Drain, "Bus done draining, processing drain event\n"); + //If we weren't able to drain before, do it now. drainEvent->process(); // Clear the drain event once we're done with it. drainEvent = NULL; } } +template void -Bus::retryWaiting() +BaseBus::Layer::retryWaiting() { // this should never be called with an empty retry list assert(!retryList.empty()); - // send a retry to the port at the head of the retry list - inRetry = 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; // 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 inRetry is still true, sendTiming wasn't called in zero time - // (e.g. the cache does this) - if (inRetry) { + // 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; - - //Bring tickNextIdle up to the present - while (tickNextIdle < curTick()) - tickNextIdle += clock; //Burn a cycle for the missed grant. - tickNextIdle += clock; - reschedule(busIdleEvent, tickNextIdle, true); + // 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(); + + occupyLayer(now + clock); } } +template void -Bus::recvRetry(PortID id) +BaseBus::Layer::recvRetry() { // 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 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 + // 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 isn't busy - if (curTick() >= tickNextIdle) { + // 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(); @@ -501,7 +314,7 @@ Bus::recvRetry(PortID id) } PortID -Bus::findPort(Addr addr) +BaseBus::findPort(Addr addr) { /* An interval tree would be a better way to do this. --ali. */ PortID dest_id = checkPortCache(addr); @@ -509,7 +322,7 @@ Bus::findPort(Addr addr) return dest_id; // Check normal port ranges - PortIter i = portMap.find(RangeSize(addr,1)); + PortMapConstIter i = portMap.find(RangeSize(addr,1)); if (i != portMap.end()) { dest_id = i->second; updatePortCache(dest_id, i->first.start, i->first.end); @@ -518,15 +331,16 @@ Bus::findPort(Addr addr) // Check if this matches the default range if (useDefaultRange) { - AddrRangeIter a_end = defaultRange.end(); - for (AddrRangeIter i = defaultRange.begin(); i != a_end; i++) { + AddrRangeConstIter a_end = defaultRange.end(); + for (AddrRangeConstIter i = defaultRange.begin(); i != a_end; i++) { if (*i == addr) { - DPRINTF(Bus, " found addr %#llx on default\n", addr); + DPRINTF(BusAddrRanges, " found addr %#llx on default\n", + addr); return defaultPortID; } } } else if (defaultPortID != InvalidPortID) { - DPRINTF(Bus, "Unable to find destination for addr %#llx, " + DPRINTF(BusAddrRanges, "Unable to find destination for addr %#llx, " "will use default port\n", addr); return defaultPortID; } @@ -537,190 +351,28 @@ Bus::findPort(Addr addr) name()); } -Tick -Bus::recvAtomic(PacketPtr pkt) -{ - DPRINTF(Bus, "recvAtomic: packet src %s addr 0x%x cmd %s\n", - slavePorts[pkt->getSrc()]->name(), pkt->getAddr(), - pkt->cmdString()); - - MemCmd snoop_response_cmd = MemCmd::InvalidCmd; - Tick snoop_response_latency = 0; - - // uncacheable requests need never be snooped - if (!pkt->req->isUncacheable()) { - // forward to all snoopers but the source - std::pair snoop_result = - forwardAtomic(pkt, pkt->getSrc()); - snoop_response_cmd = snoop_result.first; - snoop_response_latency = snoop_result.second; - } - - // even if we had a snoop response, we must continue and also - // perform the actual request at the destination - PortID dest_id = findPort(pkt->getAddr()); - - // forward the request to the appropriate destination - Tick response_latency = masterPorts[dest_id]->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()); - pkt->cmd = snoop_response_cmd; - response_latency = snoop_response_latency; - } - - pkt->finishTime = curTick() + response_latency; - return response_latency; -} - -Tick -Bus::recvAtomicSnoop(PacketPtr pkt) -{ - DPRINTF(Bus, "recvAtomicSnoop: packet src %s addr 0x%x cmd %s\n", - masterPorts[pkt->getSrc()]->name(), pkt->getAddr(), - pkt->cmdString()); - - // forward to all snoopers - std::pair snoop_result = - forwardAtomic(pkt, InvalidPortID); - MemCmd snoop_response_cmd = snoop_result.first; - Tick snoop_response_latency = snoop_result.second; - - if (snoop_response_cmd != MemCmd::InvalidCmd) - pkt->cmd = snoop_response_cmd; - - pkt->finishTime = curTick() + snoop_response_latency; - return snoop_response_latency; -} - -std::pair -Bus::forwardAtomic(PacketPtr pkt, PortID exclude_slave_port_id) -{ - // the packet may be changed on snoops, record the original source - // and command to enable us to restore it between snoops so that - // additional snoops can take place properly - PortID orig_src_id = pkt->getSrc(); - MemCmd orig_cmd = pkt->cmd; - MemCmd snoop_response_cmd = MemCmd::InvalidCmd; - Tick snoop_response_latency = 0; - - for (SlavePortIter s = snoopPorts.begin(); s != snoopPorts.end(); ++s) { - SlavePort *p = *s; - // we could have gotten this request from a snooping master - // (corresponding to our own slave port that is also in - // snoopPorts) and should not send it back to where it came - // from - if (exclude_slave_port_id == InvalidPortID || - p->getId() != exclude_slave_port_id) { - Tick latency = p->sendAtomicSnoop(pkt); - // in contrast to a functional access, we have to keep on - // going as all snoopers must be updated even if we get a - // response - 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_id); - pkt->clearDest(); - } - } - } - - // the packet is restored as part of the loop and any potential - // snoop response is part of the returned pair - return std::make_pair(snoop_response_cmd, snoop_response_latency); -} - -void -Bus::recvFunctional(PacketPtr pkt) -{ - if (!pkt->isPrint()) { - // don't do DPRINTFs on PrintReq as it clutters up the output - DPRINTF(Bus, - "recvFunctional: packet src %s addr 0x%x cmd %s\n", - slavePorts[pkt->getSrc()]->name(), pkt->getAddr(), - pkt->cmdString()); - } - - // uncacheable requests need never be snooped - if (!pkt->req->isUncacheable()) { - // forward to all snoopers but the source - forwardFunctional(pkt, pkt->getSrc()); - } - - // there is no need to continue if the snooping has found what we - // were looking for and the packet is already a response - if (!pkt->isResponse()) { - PortID dest_id = findPort(pkt->getAddr()); - - masterPorts[dest_id]->sendFunctional(pkt); - } -} - -void -Bus::recvFunctionalSnoop(PacketPtr pkt) -{ - if (!pkt->isPrint()) { - // don't do DPRINTFs on PrintReq as it clutters up the output - DPRINTF(Bus, - "recvFunctionalSnoop: packet src %s addr 0x%x cmd %s\n", - masterPorts[pkt->getSrc()]->name(), pkt->getAddr(), - pkt->cmdString()); - } - - // forward to all snoopers - forwardFunctional(pkt, InvalidPortID); -} - -void -Bus::forwardFunctional(PacketPtr pkt, PortID exclude_slave_port_id) -{ - for (SlavePortIter s = snoopPorts.begin(); s != snoopPorts.end(); ++s) { - SlavePort *p = *s; - // we could have gotten this request from a snooping master - // (corresponding to our own slave port that is also in - // snoopPorts) and should not send it back to where it came - // from - if (exclude_slave_port_id == InvalidPortID || - p->getId() != exclude_slave_port_id) - p->sendFunctionalSnoop(pkt); - - // if we get a response we are done - if (pkt->isResponse()) { - break; - } - } -} - /** Function called by the port when the bus is receiving a range change.*/ void -Bus::recvRangeChange(PortID id) +BaseBus::recvRangeChange(PortID master_port_id) { AddrRangeList ranges; AddrRangeIter iter; - if (inRecvRangeChange.count(id)) + if (inRecvRangeChange.count(master_port_id)) return; - inRecvRangeChange.insert(id); + inRecvRangeChange.insert(master_port_id); - DPRINTF(BusAddrRanges, "received RangeChange from device id %d\n", id); + DPRINTF(BusAddrRanges, "received RangeChange from device id %d\n", + master_port_id); clearPortCache(); - if (id == defaultPortID) { + if (master_port_id == defaultPortID) { defaultRange.clear(); // Only try to update these ranges if the user set a default responder. if (useDefaultRange) { + // get the address ranges of the connected slave port AddrRangeList ranges = - masterPorts[id]->getSlavePort().getAddrRanges(); + masterPorts[master_port_id]->getAddrRanges(); for(iter = ranges.begin(); iter != ranges.end(); iter++) { defaultRange.push_back(*iter); DPRINTF(BusAddrRanges, "Adding range %#llx - %#llx for default range\n", @@ -729,27 +381,29 @@ Bus::recvRangeChange(PortID id) } } else { - assert(id < masterPorts.size() && id >= 0); - MasterPort *port = masterPorts[id]; + assert(master_port_id < masterPorts.size() && master_port_id >= 0); + MasterPort *port = masterPorts[master_port_id]; // Clean out any previously existent ids - for (PortIter portIter = portMap.begin(); + for (PortMapIter portIter = portMap.begin(); portIter != portMap.end(); ) { - if (portIter->second == id) + if (portIter->second == master_port_id) portMap.erase(portIter++); else portIter++; } - ranges = port->getSlavePort().getAddrRanges(); + // get the address ranges of the connected slave port + ranges = port->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()) { + iter->start, iter->end, master_port_id); + if (portMap.insert(*iter, master_port_id) == portMap.end()) { PortID conflict_id = portMap.find(*iter)->second; fatal("%s has two ports with same range:\n\t%s\n\t%s\n", - name(), masterPorts[id]->getSlavePort().name(), + name(), + masterPorts[master_port_id]->getSlavePort().name(), masterPorts[conflict_id]->getSlavePort().name()); } } @@ -762,26 +416,26 @@ Bus::recvRangeChange(PortID id) ++p) (*p)->sendRangeChange(); - inRecvRangeChange.erase(id); + inRecvRangeChange.erase(master_port_id); } AddrRangeList -Bus::getAddrRanges(PortID id) +BaseBus::getAddrRanges() const { AddrRangeList ranges; DPRINTF(BusAddrRanges, "received address range request, returning:\n"); - for (AddrRangeIter dflt_iter = defaultRange.begin(); + for (AddrRangeConstIter 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(); + for (PortMapConstIter portIter = portMap.begin(); portIter != portMap.end(); portIter++) { bool subset = false; - for (AddrRangeIter dflt_iter = defaultRange.begin(); + for (AddrRangeConstIter dflt_iter = defaultRange.begin(); dflt_iter != defaultRange.end(); dflt_iter++) { if ((portIter->first.start < dflt_iter->start && portIter->first.end >= dflt_iter->start) || @@ -796,7 +450,7 @@ Bus::getAddrRanges(PortID id) portIter->first.start, portIter->first.end); } } - if (portIter->second != id && !subset) { + if (!subset) { ranges.push_back(portIter->first); DPRINTF(BusAddrRanges, " -- %#llx : %#llx\n", portIter->first.start, portIter->first.end); @@ -806,29 +460,22 @@ Bus::getAddrRanges(PortID id) return ranges; } -bool -Bus::isSnooping(PortID id) const -{ - // in essence, answer the question if there are snooping ports - return !snoopPorts.empty(); -} - unsigned -Bus::findBlockSize(PortID id) +BaseBus::findBlockSize() { 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 = masterPorts[p_iter->second]->peerBlockSize(); + for (MasterPortConstIter m = masterPorts.begin(); m != masterPorts.end(); + ++m) { + unsigned tmp_bs = (*m)->peerBlockSize(); if (tmp_bs > max_bs) max_bs = tmp_bs; } - for (SlavePortConstIter s = snoopPorts.begin(); s != snoopPorts.end(); + for (SlavePortConstIter s = slavePorts.begin(); s != slavePorts.end(); ++s) { unsigned tmp_bs = (*s)->peerBlockSize(); if (tmp_bs > max_bs) @@ -844,30 +491,25 @@ Bus::findBlockSize(PortID id) return max_bs; } - +template unsigned int -Bus::drain(Event * de) +BaseBus::Layer::drain(Event * de) { //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.empty() || (curTick() < tickNextIdle && - busIdleEvent.scheduled())) { + if (!retryList.empty() || state != IDLE) { + DPRINTF(Drain, "Bus not drained\n"); drainEvent = de; 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;