// supply data to any snoops that have appended themselves to
// this cache before knowing the store will fail.
blk->status |= BlkDirty;
- DPRINTF(CacheVerbose, "%s for %s addr %#llx size %d (write)\n",
- __func__, pkt->cmdString(), pkt->getAddr(), pkt->getSize());
+ DPRINTF(CacheVerbose, "%s for %s (write)\n", __func__, pkt->print());
} else if (pkt->isRead()) {
if (pkt->isLLSC()) {
blk->trackLoadLocked(pkt);
} else {
assert(pkt->isInvalidate());
invalidateBlock(blk);
- DPRINTF(CacheVerbose, "%s for %s addr %#llx size %d (invalidation)\n",
- __func__, pkt->cmdString(), pkt->getAddr(), pkt->getSize());
+ DPRINTF(CacheVerbose, "%s for %s (invalidation)\n", __func__,
+ pkt->print());
}
}
"Should never see a write in a read-only cache %s\n",
name());
- DPRINTF(CacheVerbose, "%s for %s addr %#llx size %d\n", __func__,
- pkt->cmdString(), pkt->getAddr(), pkt->getSize());
+ DPRINTF(CacheVerbose, "%s for %s\n", __func__, pkt->print());
if (pkt->req->isUncacheable()) {
- DPRINTF(Cache, "%s%s addr %#llx uncacheable\n", pkt->cmdString(),
- pkt->req->isInstFetch() ? " (ifetch)" : "",
- pkt->getAddr());
+ DPRINTF(Cache, "uncacheable: %s\n", pkt->print());
// flush and invalidate any existing block
CacheBlk *old_blk(tags->findBlock(pkt->getAddr(), pkt->isSecure()));
// that can modify its value.
blk = tags->accessBlock(pkt->getAddr(), pkt->isSecure(), lat, id);
- DPRINTF(Cache, "%s%s addr %#llx size %d (%s) %s\n", pkt->cmdString(),
- pkt->req->isInstFetch() ? " (ifetch)" : "",
- pkt->getAddr(), pkt->getSize(), pkt->isSecure() ? "s" : "ns",
+ DPRINTF(Cache, "%s %s\n", pkt->print(),
blk ? "hit " + blk->print() : "miss");
void
Cache::recvTimingSnoopResp(PacketPtr pkt)
{
- DPRINTF(Cache, "%s for %s addr %#llx size %d\n", __func__,
- pkt->cmdString(), pkt->getAddr(), pkt->getSize());
+ DPRINTF(Cache, "%s for %s\n", __func__, pkt->print());
assert(pkt->isResponse());
assert(!system->bypassCaches());
// a cache above us (but not where the packet came from) is
// responding to the request, in other words it has the line
// in Modified or Owned state
- DPRINTF(Cache, "Cache above responding to %#llx (%s): "
- "not responding\n",
- pkt->getAddr(), pkt->isSecure() ? "s" : "ns");
+ DPRINTF(Cache, "Cache above responding to %s: not responding\n",
+ pkt->print());
// if the packet needs the block to be writable, and the cache
// that has promised to respond (setting the cache responding
// by access(), that calls accessBlock() function.
cpuSidePort->schedTimingResp(pkt, request_time, true);
} else {
- DPRINTF(Cache, "%s satisfied %s addr %#llx, no response needed\n",
- __func__, pkt->cmdString(), pkt->getAddr());
+ DPRINTF(Cache, "%s satisfied %s, no response needed\n", __func__,
+ pkt->print());
// queue the packet for deletion, as the sending cache is
// still relying on it; if the block is found in access(),
if (pkt->cmd == MemCmd::CleanEvict) {
pendingDelete.reset(pkt);
} else {
- DPRINTF(Cache, "%s coalescing MSHR for %s addr %#llx "
- "size %d\n", __func__, pkt->cmdString(),
- pkt->getAddr(), pkt->getSize());
+ DPRINTF(Cache, "%s coalescing MSHR for %s\n", __func__,
+ pkt->print());
assert(pkt->req->masterId() < system->maxMasters());
mshr_hits[pkt->cmdToIndex()][pkt->req->masterId()]++;
// of date, however, there is no harm in conservatively
// assuming the block has sharers
pkt->setHasSharers();
- DPRINTF(Cache, "%s passing hasSharers from %s to %s addr %#llx "
- "size %d\n",
- __func__, cpu_pkt->cmdString(), pkt->cmdString(),
- pkt->getAddr(), pkt->getSize());
+ DPRINTF(Cache, "%s: passing hasSharers from %s to %s\n",
+ __func__, cpu_pkt->print(), pkt->print());
}
// the packet should be block aligned
assert(pkt->getAddr() == blockAlign(pkt->getAddr()));
pkt->allocate();
- DPRINTF(Cache, "%s created %s from %s for addr %#llx size %d\n",
- __func__, pkt->cmdString(), cpu_pkt->cmdString(), pkt->getAddr(),
- pkt->getSize());
+ DPRINTF(Cache, "%s: created %s from %s\n", __func__, pkt->print(),
+ cpu_pkt->print());
return pkt;
}
// follow the same flow as in recvTimingReq, and check if a cache
// above us is responding
if (pkt->cacheResponding()) {
- DPRINTF(Cache, "Cache above responding to %#llx (%s): "
- "not responding\n",
- pkt->getAddr(), pkt->isSecure() ? "s" : "ns");
+ DPRINTF(Cache, "Cache above responding to %s: not responding\n",
+ pkt->print());
// if a cache is responding, and it had the line in Owned
// rather than Modified state, we need to invalidate any
bus_pkt = pkt;
}
- DPRINTF(Cache, "Sending an atomic %s for %#llx (%s)\n",
- bus_pkt->cmdString(), bus_pkt->getAddr(),
- bus_pkt->isSecure() ? "s" : "ns");
+ DPRINTF(Cache, "%s: Sending an atomic %s\n", __func__,
+ bus_pkt->print());
#if TRACING_ON
CacheBlk::State old_state = blk ? blk->status : 0;
bool is_invalidate = bus_pkt->isInvalidate();
// We are now dealing with the response handling
- DPRINTF(Cache, "Receive response: %s for addr %#llx (%s) in "
- "state %i\n", bus_pkt->cmdString(), bus_pkt->getAddr(),
- bus_pkt->isSecure() ? "s" : "ns",
- old_state);
+ DPRINTF(Cache, "%s: Receive response: %s in state %i\n", __func__,
+ bus_pkt->print(), old_state);
// If packet was a forward, the response (if any) is already
// in place in the bus_pkt == pkt structure, so we don't need
|| writeBuffer.checkFunctional(pkt, blk_addr)
|| memSidePort->checkFunctional(pkt);
- DPRINTF(CacheVerbose, "functional %s %#llx (%s) %s%s%s\n",
- pkt->cmdString(), pkt->getAddr(), is_secure ? "s" : "ns",
+ DPRINTF(CacheVerbose, "%s: %s %s%s%s\n", __func__, pkt->print(),
(blk && blk->isValid()) ? "valid " : "",
have_data ? "data " : "", done ? "done " : "");
bool is_error = pkt->isError();
if (is_error) {
- DPRINTF(Cache, "Cache received packet with error for addr %#llx (%s), "
- "cmd: %s\n", pkt->getAddr(), pkt->isSecure() ? "s" : "ns",
- pkt->cmdString());
+ DPRINTF(Cache, "%s: Cache received %s with error\n", __func__,
+ pkt->print());
}
- DPRINTF(Cache, "Handling response %s for addr %#llx size %d (%s)\n",
- pkt->cmdString(), pkt->getAddr(), pkt->getSize(),
- pkt->isSecure() ? "s" : "ns");
+ DPRINTF(Cache, "%s: Handling response %s\n", __func__,
+ pkt->print());
// if this is a write, we should be looking at an uncacheable
// write
// propagate that. Response should not have
// isInvalidate() set otherwise.
tgt_pkt->cmd = MemCmd::ReadRespWithInvalidate;
- DPRINTF(Cache, "%s updated cmd to %s for addr %#llx\n",
- __func__, tgt_pkt->cmdString(), tgt_pkt->getAddr());
+ DPRINTF(Cache, "%s: updated cmd to %s\n", __func__,
+ tgt_pkt->print());
}
// Reset the bus additional time as it is now accounted for
tgt_pkt->headerDelay = tgt_pkt->payloadDelay = 0;
blk->invalidate();
}
- DPRINTF(CacheVerbose, "Leaving %s with %s for addr %#llx\n", __func__,
- pkt->cmdString(), pkt->getAddr());
+ DPRINTF(CacheVerbose, "%s: Leaving with %s\n", __func__, pkt->print());
delete pkt;
}
new Packet(req, blk->isDirty() ?
MemCmd::WritebackDirty : MemCmd::WritebackClean);
- DPRINTF(Cache, "Create Writeback %#llx writable: %d, dirty: %d\n",
- pkt->getAddr(), blk->isWritable(), blk->isDirty());
+ DPRINTF(Cache, "Create Writeback %s writable: %d, dirty: %d\n",
+ pkt->print(), blk->isWritable(), blk->isDirty());
if (blk->isWritable()) {
// not asserting shared means we pass the block in modified
PacketPtr pkt = new Packet(req, MemCmd::CleanEvict);
pkt->allocate();
- DPRINTF(Cache, "%s%s %x Create CleanEvict\n", pkt->cmdString(),
- pkt->req->isInstFetch() ? " (ifetch)" : "",
- pkt->getAddr());
+ DPRINTF(Cache, "Create CleanEvict %s\n", pkt->print());
return pkt;
}
assert(req_pkt->isRequest());
assert(req_pkt->needsResponse());
- DPRINTF(Cache, "%s for %s addr %#llx size %d\n", __func__,
- req_pkt->cmdString(), req_pkt->getAddr(), req_pkt->getSize());
+ DPRINTF(Cache, "%s: for %s\n", __func__, req_pkt->print());
// timing-mode snoop responses require a new packet, unless we
// already made a copy...
PacketPtr pkt = req_pkt;
Tick forward_time = clockEdge(forwardLatency) + pkt->headerDelay;
// Here we reset the timing of the packet.
pkt->headerDelay = pkt->payloadDelay = 0;
- DPRINTF(CacheVerbose,
- "%s created response: %s addr %#llx size %d tick: %lu\n",
- __func__, pkt->cmdString(), pkt->getAddr(), pkt->getSize(),
- forward_time);
+ DPRINTF(CacheVerbose, "%s: created response: %s tick: %lu\n", __func__,
+ pkt->print(), forward_time);
memSidePort->schedTimingSnoopResp(pkt, forward_time, true);
}
Cache::handleSnoop(PacketPtr pkt, CacheBlk *blk, bool is_timing,
bool is_deferred, bool pending_inval)
{
- DPRINTF(CacheVerbose, "%s for %s addr %#llx size %d\n", __func__,
- pkt->cmdString(), pkt->getAddr(), pkt->getSize());
+ DPRINTF(CacheVerbose, "%s: for %s\n", __func__, pkt->print());
// deferred snoops can only happen in timing mode
assert(!(is_deferred && !is_timing));
// pending_inval only makes sense on deferred snoops
// have the invalidate flag, and we need a suitable way of dealing
// with this case
panic_if(invalidate && pkt->req->isUncacheable(),
- "%s got an invalidating uncacheable snoop request %s to %#llx",
- name(), pkt->cmdString(), pkt->getAddr());
+ "%s got an invalidating uncacheable snoop request %s",
+ name(), pkt->print());
uint32_t snoop_delay = 0;
}
if (!blk || !blk->isValid()) {
+ DPRINTF(CacheVerbose, "%s: snoop miss for %s\n", __func__,
+ pkt->print());
if (is_deferred) {
// we no longer have the block, and will not respond, but a
// packet was allocated in MSHR::handleSnoop and we have
delete pkt;
}
-
- DPRINTF(CacheVerbose, "%s snoop miss for %s addr %#llx size %d\n",
- __func__, pkt->cmdString(), pkt->getAddr(), pkt->getSize());
return snoop_delay;
} else {
- DPRINTF(Cache, "%s snoop hit for %s addr %#llx size %d, "
- "old state is %s\n", __func__, pkt->cmdString(),
- pkt->getAddr(), pkt->getSize(), blk->print());
+ DPRINTF(Cache, "%s: snoop hit for %s, old state is %s\n", __func__,
+ pkt->print(), blk->print());
}
chatty_assert(!(isReadOnly && blk->isDirty()),
// downstream caches observe.
if (pkt->mustCheckAbove()) {
DPRINTF(Cache, "Found addr %#llx in upper level cache for snoop %s "
- "from lower cache\n", pkt->getAddr(), pkt->cmdString());
+ "from lower cache\n", pkt->getAddr(), pkt->print());
pkt->setBlockCached();
return snoop_delay;
}
// if we are returning a writable and dirty (Modified) line,
// we should be invalidating the line
panic_if(!invalidate && !pkt->hasSharers(),
- "%s is passing a Modified line through %s to %#llx, "
- "but keeping the block",
- name(), pkt->cmdString(), pkt->getAddr());
+ "%s is passing a Modified line through %s, "
+ "but keeping the block", name(), pkt->print());
if (is_timing) {
doTimingSupplyResponse(pkt, blk->data, is_deferred, pending_inval);
void
Cache::recvTimingSnoopReq(PacketPtr pkt)
{
- DPRINTF(CacheVerbose, "%s for %s addr %#llx size %d\n", __func__,
- pkt->cmdString(), pkt->getAddr(), pkt->getSize());
+ DPRINTF(CacheVerbose, "%s: for %s\n", __func__, pkt->print());
// Snoops shouldn't happen when bypassing caches
assert(!system->bypassCaches());
// Inform request(Prefetch, CleanEvict or Writeback) from below of
// MSHR hit, set setBlockCached.
if (mshr && pkt->mustCheckAbove()) {
- DPRINTF(Cache, "Setting block cached for %s from"
- "lower cache on mshr hit %#x\n",
- pkt->cmdString(), pkt->getAddr());
+ DPRINTF(Cache, "Setting block cached for %s from lower cache on "
+ "mshr hit\n", pkt->print());
pkt->setBlockCached();
return;
}
// propagate the BLOCK_CACHED flag in Writeback packets and prevent
// any CleanEvicts from travelling down the memory hierarchy.
pkt->setBlockCached();
- DPRINTF(Cache, "Squashing %s from lower cache on writequeue hit"
- " %#x\n", pkt->cmdString(), pkt->getAddr());
+ DPRINTF(Cache, "%s: Squashing %s from lower cache on writequeue "
+ "hit\n", __func__, pkt->print());
return;
}
// use request from 1st target
PacketPtr tgt_pkt = mshr->getTarget()->pkt;
- DPRINTF(Cache, "%s MSHR %s for addr %#llx size %d\n", __func__,
- tgt_pkt->cmdString(), tgt_pkt->getAddr(),
- tgt_pkt->getSize());
+ DPRINTF(Cache, "%s: MSHR %s\n", __func__, tgt_pkt->print());
CacheBlk *blk = tags->findBlock(mshr->blkAddr, mshr->isSecure);
// always a single target for write queue entries
PacketPtr tgt_pkt = wq_entry->getTarget()->pkt;
- DPRINTF(Cache, "%s write %s for addr %#llx size %d\n", __func__,
- tgt_pkt->cmdString(), tgt_pkt->getAddr(),
- tgt_pkt->getSize());
+ DPRINTF(Cache, "%s: write %s\n", __func__, tgt_pkt->print());
// forward as is, both for evictions and uncacheable writes
if (!memSidePort->sendTimingReq(tgt_pkt)) {
// test if the crossbar should be considered occupied for the current
// port, and exclude express snoops from the check
if (!is_express_snoop && !reqLayers[master_port_id]->tryTiming(src_port)) {
- DPRINTF(CoherentXBar, "recvTimingReq: src %s %s 0x%x BUSY\n",
- src_port->name(), pkt->cmdString(), pkt->getAddr());
+ DPRINTF(CoherentXBar, "%s: src %s packet %s BUSY\n", __func__,
+ src_port->name(), pkt->print());
return false;
}
- DPRINTF(CoherentXBar, "recvTimingReq: src %s %s expr %d 0x%x\n",
- src_port->name(), pkt->cmdString(), is_express_snoop,
- pkt->getAddr());
+ DPRINTF(CoherentXBar, "%s: src %s packet %s\n", __func__,
+ src_port->name(), pkt->print());
// store size and command as they might be modified when
// forwarding the packet
// the xbar has to be charged also with to lookup latency
// of the snoop filter
pkt->headerDelay += sf_res.second * clockPeriod();
- DPRINTF(CoherentXBar, "recvTimingReq: src %s %s 0x%x"\
- " SF size: %i lat: %i\n", src_port->name(),
- pkt->cmdString(), pkt->getAddr(), sf_res.first.size(),
- sf_res.second);
+ DPRINTF(CoherentXBar, "%s: src %s packet %s SF size: %i lat: %i\n",
+ __func__, src_port->name(), pkt->print(),
+ sf_res.first.size(), sf_res.second);
if (pkt->isEviction()) {
// for block-evicting packets, i.e. writebacks and
// modify the address upon a sendTimingRequest
const Addr addr(pkt->getAddr());
if (sink_packet) {
- DPRINTF(CoherentXBar, "Not forwarding %s to %#llx\n",
- pkt->cmdString(), pkt->getAddr());
+ DPRINTF(CoherentXBar, "%s: Not forwarding %s\n", __func__,
+ pkt->print());
} else {
// determine if we are forwarding the packet, or responding to
// it
// restore the header delay
pkt->headerDelay = old_header_delay;
- DPRINTF(CoherentXBar, "recvTimingReq: src %s %s 0x%x RETRY\n",
- src_port->name(), pkt->cmdString(), pkt->getAddr());
+ DPRINTF(CoherentXBar, "%s: src %s packet %s RETRY\n", __func__,
+ src_port->name(), pkt->print());
// update the layer state and schedule an idle event
reqLayers[master_port_id]->failedTiming(src_port,
// test if the crossbar should be considered occupied for the
// current port
if (!respLayers[slave_port_id]->tryTiming(src_port)) {
- DPRINTF(CoherentXBar, "recvTimingResp: src %s %s 0x%x BUSY\n",
- src_port->name(), pkt->cmdString(), pkt->getAddr());
+ DPRINTF(CoherentXBar, "%s: src %s packet %s BUSY\n", __func__,
+ src_port->name(), pkt->print());
return false;
}
- DPRINTF(CoherentXBar, "recvTimingResp: src %s %s 0x%x\n",
- src_port->name(), pkt->cmdString(), pkt->getAddr());
+ DPRINTF(CoherentXBar, "%s: src %s packet %s\n", __func__,
+ src_port->name(), pkt->print());
// store size and command as they might be modified when
// forwarding the packet
void
CoherentXBar::recvTimingSnoopReq(PacketPtr pkt, PortID master_port_id)
{
- DPRINTF(CoherentXBar, "recvTimingSnoopReq: src %s %s 0x%x\n",
- masterPorts[master_port_id]->name(), pkt->cmdString(),
- pkt->getAddr());
+ DPRINTF(CoherentXBar, "%s: src %s packet %s\n", __func__,
+ masterPorts[master_port_id]->name(), pkt->print());
// update stats here as we know the forwarding will succeed
unsigned int pkt_size = pkt->hasData() ? pkt->getSize() : 0;
// the xbar has to be charged also with to lookup latency
// of the snoop filter
pkt->headerDelay += sf_res.second * clockPeriod();
- DPRINTF(CoherentXBar, "recvTimingSnoopReq: src %s %s 0x%x"\
- " SF size: %i lat: %i\n", masterPorts[master_port_id]->name(),
- pkt->cmdString(), pkt->getAddr(), sf_res.first.size(),
- sf_res.second);
+ DPRINTF(CoherentXBar, "%s: src %s packet %s SF size: %i lat: %i\n",
+ __func__, masterPorts[master_port_id]->name(), pkt->print(),
+ sf_res.first.size(), sf_res.second);
// forward to all snoopers
forwardTiming(pkt, InvalidPortID, sf_res.first);
if (forwardAsSnoop) {
assert(dest_port_id < snoopLayers.size());
if (!snoopLayers[dest_port_id]->tryTiming(src_port)) {
- DPRINTF(CoherentXBar, "recvTimingSnoopResp: src %s %s 0x%x BUSY\n",
- src_port->name(), pkt->cmdString(), pkt->getAddr());
+ DPRINTF(CoherentXBar, "%s: src %s packet %s BUSY\n", __func__,
+ src_port->name(), pkt->print());
return false;
}
} else {
MasterPort* snoop_port = snoopRespPorts[slave_port_id];
assert(dest_port_id < respLayers.size());
if (!respLayers[dest_port_id]->tryTiming(snoop_port)) {
- DPRINTF(CoherentXBar, "recvTimingSnoopResp: src %s %s 0x%x BUSY\n",
- snoop_port->name(), pkt->cmdString(), pkt->getAddr());
+ DPRINTF(CoherentXBar, "%s: src %s packet %s BUSY\n", __func__,
+ snoop_port->name(), pkt->print());
return false;
}
}
- DPRINTF(CoherentXBar, "recvTimingSnoopResp: src %s %s 0x%x\n",
- src_port->name(), pkt->cmdString(), pkt->getAddr());
+ DPRINTF(CoherentXBar, "%s: src %s packet %s\n", __func__,
+ src_port->name(), pkt->print());
// store size and command as they might be modified when
// forwarding the packet
*slavePorts[dest_port_id]);
}
- DPRINTF(CoherentXBar, "recvTimingSnoopResp: src %s %s 0x%x"\
- " FWD RESP\n", src_port->name(), pkt->cmdString(),
- pkt->getAddr());
+ DPRINTF(CoherentXBar, "%s: src %s packet %s FWD RESP\n", __func__,
+ src_port->name(), pkt->print());
// as a normal response, it should go back to a master through
// one of our slave ports, we also pay for any outstanding
CoherentXBar::forwardTiming(PacketPtr pkt, PortID exclude_slave_port_id,
const std::vector<QueuedSlavePort*>& dests)
{
- DPRINTF(CoherentXBar, "%s for %s address %x size %d\n", __func__,
- pkt->cmdString(), pkt->getAddr(), pkt->getSize());
+ DPRINTF(CoherentXBar, "%s for %s\n", __func__, pkt->print());
// snoops should only happen if the system isn't bypassing caches
assert(!system->bypassCaches());
Tick
CoherentXBar::recvAtomic(PacketPtr pkt, PortID slave_port_id)
{
- DPRINTF(CoherentXBar, "recvAtomic: packet src %s addr 0x%x cmd %s\n",
- slavePorts[slave_port_id]->name(), pkt->getAddr(),
- pkt->cmdString());
+ DPRINTF(CoherentXBar, "%s: src %s packet %s\n", __func__,
+ slavePorts[slave_port_id]->name(), pkt->print());
unsigned int pkt_size = pkt->hasData() ? pkt->getSize() : 0;
unsigned int pkt_cmd = pkt->cmdToIndex();
auto sf_res =
snoopFilter->lookupRequest(pkt, *slavePorts[slave_port_id]);
snoop_response_latency += sf_res.second * clockPeriod();
- DPRINTF(CoherentXBar, "%s: src %s %s 0x%x"\
- " SF size: %i lat: %i\n", __func__,
- slavePorts[slave_port_id]->name(), pkt->cmdString(),
- pkt->getAddr(), sf_res.first.size(), sf_res.second);
+ DPRINTF(CoherentXBar, "%s: src %s packet %s SF size: %i lat: %i\n",
+ __func__, slavePorts[slave_port_id]->name(), pkt->print(),
+ sf_res.first.size(), sf_res.second);
// let the snoop filter know about the success of the send
// operation, and do it even before sending it onwards to
PortID master_port_id = findPort(pkt->getAddr());
if (sink_packet) {
- DPRINTF(CoherentXBar, "Not forwarding %s to %#llx\n",
- pkt->cmdString(), pkt->getAddr());
+ DPRINTF(CoherentXBar, "%s: Not forwarding %s\n", __func__,
+ pkt->print());
} else {
if (!pointOfCoherency || pkt->isRead() || pkt->isWrite()) {
// forward the request to the appropriate destination
Tick
CoherentXBar::recvAtomicSnoop(PacketPtr pkt, PortID master_port_id)
{
- DPRINTF(CoherentXBar, "recvAtomicSnoop: packet src %s addr 0x%x cmd %s\n",
- masterPorts[master_port_id]->name(), pkt->getAddr(),
- pkt->cmdString());
+ DPRINTF(CoherentXBar, "%s: src %s packet %s\n", __func__,
+ masterPorts[master_port_id]->name(), pkt->print());
// add the request snoop data
unsigned int pkt_size = pkt->hasData() ? pkt->getSize() : 0;
if (snoopFilter) {
auto sf_res = snoopFilter->lookupSnoop(pkt);
snoop_response_latency += sf_res.second * clockPeriod();
- DPRINTF(CoherentXBar, "%s: src %s %s 0x%x SF size: %i lat: %i\n",
- __func__, masterPorts[master_port_id]->name(), pkt->cmdString(),
- pkt->getAddr(), sf_res.first.size(), sf_res.second);
+ DPRINTF(CoherentXBar, "%s: src %s packet %s SF size: %i lat: %i\n",
+ __func__, masterPorts[master_port_id]->name(), pkt->print(),
+ sf_res.first.size(), sf_res.second);
snoop_result = forwardAtomic(pkt, InvalidPortID, master_port_id,
sf_res.first);
} else {
{
if (!pkt->isPrint()) {
// don't do DPRINTFs on PrintReq as it clutters up the output
- DPRINTF(CoherentXBar,
- "recvFunctional: packet src %s addr 0x%x cmd %s\n",
- slavePorts[slave_port_id]->name(), pkt->getAddr(),
- pkt->cmdString());
+ DPRINTF(CoherentXBar, "%s: src %s packet %s\n", __func__,
+ slavePorts[slave_port_id]->name(), pkt->print());
}
if (!system->bypassCaches()) {
{
if (!pkt->isPrint()) {
// don't do DPRINTFs on PrintReq as it clutters up the output
- DPRINTF(CoherentXBar,
- "recvFunctionalSnoop: packet src %s addr 0x%x cmd %s\n",
- masterPorts[master_port_id]->name(), pkt->getAddr(),
- pkt->cmdString());
+ DPRINTF(CoherentXBar, "%s: src %s packet %s\n", __func__,
+ masterPorts[master_port_id]->name(), pkt->print());
}
for (const auto& p : slavePorts) {
projects / gem5.git / commitdiff