mem/cache/cache.cc

81 Cache::satisfyRequest(PacketPtr pkt, CacheBlk *blk,
84     BaseCache::satisfyRequest(pkt, blk);
100                 if (blk->isDirty()) {
102                     blk->status &= ~BlkDirty;
104             } else if (blk->isWritable() && !pending_downgrade &&
117                 if (blk->isDirty()) {
139                         blk->status &= ~BlkDirty;
164 Cache::access(PacketPtr pkt, CacheBlk *&blk, Cycles &lat,
183         blk = nullptr;
189     return BaseCache::access(pkt, blk, lat, writebacks);
316 Cache::handleTimingReqHit(PacketPtr pkt, CacheBlk *blk, Tick request_time)
323     BaseCache::handleTimingReqHit(pkt, blk, request_time);
327 Cache::handleTimingReqMiss(PacketPtr pkt, CacheBlk *blk, Tick forward_time,
335         assert(!blk || !blk->isValid());
402     BaseCache::handleTimingReqMiss(pkt, mshr, blk, forward_time, request_time);
480 Cache::createMissPacket(PacketPtr cpu_pkt, CacheBlk *blk,
487     bool blkValid = blk && blk->isValid();
507         assert(!blkValid || !blk->isWritable());
513         // only reason to be here is that blk is read only and we need
516         assert(!blk->isWritable());
566 Cache::handleAtomicReqMiss(PacketPtr pkt, CacheBlk *&blk,
586     PacketPtr bus_pkt = createMissPacket(pkt, blk, pkt->needsWritable(),
601     CacheBlk::State old_state = blk ? blk->status : 0;
629                 blk = handleFill(bus_pkt, blk, writebacks, allocate);
630                 assert(blk != NULL);
632                 satisfyRequest(pkt, blk);
637                 blk = handleFill(bus_pkt, blk, writebacks,
639                 satisfyRequest(pkt, blk);
640                 maintainClusivity(pkt->fromCache(), blk);
650     if (is_invalidate && blk && blk->isValid()) {
651         invalidateBlock(blk);
689 Cache::serviceMSHRTargets(MSHR *mshr, const PacketPtr pkt, CacheBlk *blk)
732                     assert(blk);
733                     blk->status |= BlkDirty;
755                 assert(blk);
756                 assert(blk->isWritable());
759             if (blk && blk->isValid() && !mshr->isForward) {
760                 satisfyRequest(tgt_pkt, blk, true, mshr->hasPostDowngrade());
801                 if (is_invalidate && blk && blk->isValid()) {
802                     invalidateBlock(blk);
842             if (blk)
843                 blk->status |= BlkHWPrefetched;
864             handleSnoop(tgt_pkt, blk, true, true, mshr->hasPostInvalidate());
872     maintainClusivity(targets.hasFromCache, blk);
874     if (blk && blk->isValid()) {
879             invalidateBlock(blk);
881             blk->status &= ~BlkWritable;
887 Cache::evictBlock(CacheBlk *blk)
889     PacketPtr pkt = (blk->isDirty() || writebackClean) ?
890         writebackBlk(blk) : cleanEvictBlk(blk);
892     invalidateBlock(blk);
898 Cache::cleanEvictBlk(CacheBlk *blk)
901     assert(blk && blk->isValid() && !blk->isDirty());
905         regenerateBlkAddr(blk), blkSize, 0, Request::wbMasterId);
907     if (blk->isSecure())
910     req->taskId(blk->task_id);
971 Cache::handleSnoop(PacketPtr pkt, CacheBlk *blk, bool is_timing,
1044     bool blk_valid = blk && blk->isValid();
1046         if (blk_valid && blk->isDirty()) {
1048                     __func__, pkt->print(), blk->print());
1049             PacketPtr wb_pkt = writecleanBlk(blk, pkt->req->getDest(), pkt->id);
1082                 pkt->print(), blk->print());
1091         respond = blk->isDirty() && pkt->needsResponse();
1093         chatty_assert(!(isReadOnly && blk->isDirty()), "Should never have "
1119             blk->status &= ~BlkWritable;
1120         DPRINTF(Cache, "new state is %s\n", blk->print());
1128         if (!pkt->isClean() && blk->isWritable()) {
1151             doTimingSupplyResponse(pkt, blk->data, is_deferred, pending_inval);
1157                 pkt->setDataFromBlock(blk->data, blkSize);
1163             snoop_delay += compressor->getDecompressionLatency(blk);
1175         invalidateBlock(blk);
1176         DPRINTF(Cache, "new state is %s\n", blk->print());
1194     CacheBlk *blk = tags->findBlock(pkt->getAddr(), is_secure);
1219         DPRINTF(Cache, "Deferring snoop on in-service MSHR to blk %#llx (%s)."
1293     uint32_t snoop_delay = handleSnoop(pkt, blk, true, false, false);
1309     CacheBlk *blk = tags->findBlock(pkt->getAddr(), pkt->isSecure());
1310     uint32_t snoop_delay = handleSnoop(pkt, blk, false, false, false);