* Definition of a bus object.
*/
-
+#include <algorithm>
#include <limits>
#include "base/misc.hh"
//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. Anthing that happens later will have to "wait" for
- //the end of that cycle, and then start using the bus after that.
- while (tickNextIdle < curTick)
- tickNextIdle += clock;
+ //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;
+ }
// 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.
// We're using the "adding instead of dividing" trick again here
if (pkt->hasData()) {
int dataSize = pkt->getSize();
- for (int transmitted = 0; transmitted < dataSize;
- transmitted += width) {
+ 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.
bool
Bus::recvTiming(PacketPtr pkt)
{
- Port *port;
- DPRINTF(Bus, "recvTiming: packet src %d dest %d addr 0x%x cmd %s result %d\n",
- pkt->getSrc(), pkt->getDest(), pkt->getAddr(), pkt->cmdString(),
- pkt->result);
+ 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)
// If the bus is busy, or other devices are in line ahead of the current
// one, put this device on the retry list.
if (tickNextIdle > curTick ||
- (retryList.size() && (!inRetry || pktPort != retryList.front()))) {
+ (retryList.size() && (!inRetry || pktPort != retryList.front())))
+ {
addToRetryList(pktPort);
DPRINTF(Bus, "recvTiming: Bus is busy, returning false\n");
return false;
// Make sure to clear the snoop commit flag so it doesn't think an
// access has been handled twice.
if (dest == Packet::Broadcast) {
- port = findPort(pkt->getAddr(), pkt->getSrc());
- pkt->flags &= ~SNOOP_COMMIT;
- if (timingSnoop(pkt, port ? port : interfaces[pkt->getSrc()])) {
- bool success;
-
- pkt->flags |= SNOOP_COMMIT;
- success = timingSnoop(pkt, port ? port : interfaces[pkt->getSrc()]);
- assert(success);
-
- if (pkt->flags & SATISFIED) {
- //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;
+ port_id = findPort(pkt->getAddr());
+ timingSnoop(pkt, interfaces[port_id]);
+
+ if (pkt->memInhibitAsserted()) {
+ //Cache-Cache transfer occuring
+ if (inRetry) {
+ retryList.front()->onRetryList(false);
+ retryList.pop_front();
+ inRetry = false;
}
- } else {
- //Snoop didn't succeed
- DPRINTF(Bus, "Adding1 a retry to RETRY list %d\n",
- pktPort->getId());
- addToRetryList(pktPort);
- return 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 = interfaces[dest];
+ port_id = dest;
}
occupyBus(pkt);
- if (port) {
- if (port->sendTiming(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) {
void
Bus::recvRetry(int id)
{
- DPRINTF(Bus, "Received a retry from %s\n", id == -1 ? "self" : interfaces[id]->getPeer()->name());
// If there's anything waiting, and the bus isn't busy...
if (retryList.size() && curTick >= tickNextIdle) {
//retryingPort = retryList.front();
}
}
-Port *
-Bus::findPort(Addr addr, int id)
+int
+Bus::findPort(Addr addr)
{
/* An interval tree would be a better way to do this. --ali. */
int dest_id = -1;
- AddrRangeIter iter;
- range_map<Addr,int>::iterator i;
- i = portMap.find(RangeSize(addr,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 (iter = defaultRange.begin(); iter != defaultRange.end(); iter++) {
+ for (AddrRangeIter iter = defaultRange.begin();
+ iter != defaultRange.end(); iter++) {
if (*iter == addr) {
DPRINTF(Bus, " found addr %#llx on default\n", addr);
- return defaultPort;
+ return defaultId;
}
}
DPRINTF(Bus, "Unable to find destination for addr: %#llx, will use "
"default port", addr);
- return defaultPort;
- }
- }
-
-
- // we shouldn't be sending this back to where it came from
- // do the snoop access and then we should terminate
- // the cyclical call.
- if (dest_id == id)
- return 0;
-
- return interfaces[dest_id];
-}
-
-std::vector<int>
-Bus::findSnoopPorts(Addr addr, int id)
-{
- int i = 0;
- AddrRangeIter iter;
- std::vector<int> ports;
-
- while (i < portSnoopList.size())
- {
- if (portSnoopList[i].range == addr && portSnoopList[i].portId != id) {
- //Careful to not overlap ranges
- //or snoop will be called more than once on the port
-
- //@todo Fix this hack because ranges are overlapping
- //need to make sure we dont't create overlapping ranges
- bool hack_overlap = false;
- int size = ports.size();
- for (int j=0; j < size; j++) {
- if (ports[j] == portSnoopList[i].portId)
- hack_overlap = true;
- }
-
- if (!hack_overlap)
- ports.push_back(portSnoopList[i].portId);
-// DPRINTF(Bus, " found snoop addr %#llx on device%d\n", addr,
-// portSnoopList[i].portId);
+ return defaultId;
}
- i++;
}
- return ports;
-}
-
-Tick
-Bus::atomicSnoop(PacketPtr pkt, Port *responder)
-{
- std::vector<int> ports = findSnoopPorts(pkt->getAddr(), pkt->getSrc());
- Tick response_time = 0;
- while (!ports.empty())
- {
- if (interfaces[ports.back()] != responder) {
- Tick response = interfaces[ports.back()]->sendAtomic(pkt);
- if (response) {
- assert(!response_time); //Multiple responders
- response_time = response;
- }
- }
- ports.pop_back();
- }
- return response_time;
+ return dest_id;
}
void
Bus::functionalSnoop(PacketPtr pkt, Port *responder)
{
- std::vector<int> ports = findSnoopPorts(pkt->getAddr(), pkt->getSrc());
-
- //The packet may be changed by another bus on snoops, restore the id after each
- int id = pkt->getSrc();
- while (!ports.empty() && pkt->result != Packet::Success)
- {
- if (interfaces[ports.back()] != responder)
- interfaces[ports.back()]->sendFunctional(pkt);
- ports.pop_back();
- pkt->setSrc(id);
+ // 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);
}
}
bool
Bus::timingSnoop(PacketPtr pkt, Port* responder)
{
- std::vector<int> ports = findSnoopPorts(pkt->getAddr(), pkt->getSrc());
- bool success = true;
-
- while (!ports.empty() && success)
- {
- if (interfaces[ports.back()] != responder) //Don't call if responder also, once will do
- success = interfaces[ports.back()]->sendTiming(pkt);
- ports.pop_back();
+ 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;
+ }
}
- return success;
+ return true;
}
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);
- pkt->flags |= SNOOP_COMMIT;
+ 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);
+ }
+ }
+ }
+
+ Tick response_latency = 0;
- // Assume one bus cycle in order to get through. This may have
- // some clock skew issues yet again...
- pkt->finishTime = curTick + clock;
+ // 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);
+ }
- Port *port = findPort(pkt->getAddr(), pkt->getSrc());
- Tick snoopTime = atomicSnoop(pkt, port ? port : interfaces[pkt->getSrc()]);
+ // 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;
+ }
- if (snoopTime)
- return snoopTime; //Snoop satisfies it
- else if (port)
- return port->sendAtomic(pkt);
- else
- return 0;
+ // 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
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);
- pkt->flags |= SNOOP_COMMIT;
- Port* port = findPort(pkt->getAddr(), pkt->getSrc());
- functionalSnoop(pkt, port ? port : interfaces[pkt->getSrc()]);
+ int port_id = findPort(pkt->getAddr());
+ Port *port = interfaces[port_id];
+ functionalSnoop(pkt, port);
- // If the snooping found what we were looking for, we're done.
- if (pkt->result != Packet::Success && port) {
+ // If the snooping hasn't found what we were looking for, keep going.
+ if (!pkt->isResponse() && port_id != pkt->getSrc()) {
port->sendFunctional(pkt);
}
}
Bus::recvStatusChange(Port::Status status, int id)
{
AddrRangeList ranges;
- AddrRangeList snoops;
+ bool snoops;
AddrRangeIter iter;
assert(status == Port::RangeChange &&
// Only try to update these ranges if the user set a default responder.
if (responderSet) {
defaultPort->getPeerAddressRanges(ranges, snoops);
- assert(snoops.size() == 0);
+ 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",
} else {
assert((id < maxId && id >= 0) || id == defaultId);
- Port *port = interfaces[id];
- range_map<Addr,int>::iterator portIter;
- std::vector<DevMap>::iterator snoopIter;
+ BusPort *port = interfaces[id];
// Clean out any previously existent ids
- for (portIter = portMap.begin(); portIter != portMap.end(); ) {
+ for (PortIter portIter = portMap.begin();
+ portIter != portMap.end(); ) {
if (portIter->second == id)
portMap.erase(portIter++);
else
portIter++;
}
- for (snoopIter = portSnoopList.begin(); snoopIter != portSnoopList.end(); ) {
- if (snoopIter->portId == id)
- snoopIter = portSnoopList.erase(snoopIter);
+ for (SnoopIter s_iter = snoopPorts.begin();
+ s_iter != snoopPorts.end(); ) {
+ if ((*s_iter)->getId() == id)
+ s_iter = snoopPorts.erase(s_iter);
else
- snoopIter++;
+ s_iter++;
}
port->getPeerAddressRanges(ranges, snoops);
- for(iter = snoops.begin(); iter != snoops.end(); iter++) {
- DevMap dm;
- dm.portId = id;
- dm.range = *iter;
-
- //@todo, make sure we don't overlap ranges
- DPRINTF(BusAddrRanges, "Adding snoop range %#llx - %#llx for id %d\n",
- dm.range.start, dm.range.end, id);
- portSnoopList.push_back(dm);
+ if (snoops) {
+ DPRINTF(BusAddrRanges, "Adding id %d to snoop list\n", id);
+ snoopPorts.push_back(port);
}
- for(iter = ranges.begin(); iter != ranges.end(); iter++) {
+ 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())
}
void
-Bus::addressRanges(AddrRangeList &resp, AddrRangeList &snoop, int id)
+Bus::addressRanges(AddrRangeList &resp, bool &snoop, int id)
{
- std::vector<DevMap>::iterator snoopIter;
- range_map<Addr,int>::iterator portIter;
- AddrRangeIter dflt_iter;
- bool subset;
-
resp.clear();
- snoop.clear();
+ snoop = false;
DPRINTF(BusAddrRanges, "received address range request, returning:\n");
- for (dflt_iter = defaultRange.begin(); dflt_iter != defaultRange.end();
- dflt_iter++) {
+ 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 = portMap.begin(); portIter != portMap.end(); portIter++) {
- subset = false;
- for (dflt_iter = defaultRange.begin(); dflt_iter != defaultRange.end();
- dflt_iter++) {
+ 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 &&
}
}
- for (snoopIter = portSnoopList.begin();
- snoopIter != portSnoopList.end(); snoopIter++)
- {
- if (snoopIter->portId != id) {
- snoop.push_back(snoopIter->range);
- DPRINTF(BusAddrRanges, " -- Snoop: %#llx : %#llx\n",
- snoopIter->range.start, snoopIter->range.end);
- //@todo We need to properly insert snoop ranges
- //not overlapping the ranges (multiple)
+ for (SnoopIter s_iter = snoopPorts.begin(); s_iter != snoopPorts.end();
+ s_iter++) {
+ if ((*s_iter)->getId() != id) {
+ snoop = true;
+ break;
}
}
}
if (cachedBlockSizeValid)
return cachedBlockSize;
- int max_bs = -1, tmp_bs;
- range_map<Addr,int>::iterator portIter;
- std::vector<DevMap>::iterator snoopIter;
- for (portIter = portMap.begin(); portIter != portMap.end(); portIter++) {
- tmp_bs = interfaces[portIter->second]->peerBlockSize();
+ 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 = portSnoopList.begin();
- snoopIter != portSnoopList.end(); snoopIter++) {
- tmp_bs = interfaces[snoopIter->portId]->peerBlockSize();
+ 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;
}
}
}
+void
+Bus::startup()
+{
+ if (tickNextIdle < curTick)
+ tickNextIdle = (curTick / clock) * clock + clock;
+}
+
BEGIN_DECLARE_SIM_OBJECT_PARAMS(Bus)
Param<int> bus_id;
projects / gem5.git / blobdiff