mem/cache/base.cc

49 #include "mem/cache/base.hh"
58 #include "mem/cache/compressors/base.hh"
59 #include "mem/cache/mshr.hh"
60 #include "mem/cache/prefetch/base.hh"
61 #include "mem/cache/queue_entry.hh"
62 #include "mem/cache/tags/super_blk.hh"
232         // queue the packet for deletion, as the sending cache is
266                 // outstanding cache maintenance requests.
312                 // out of the cache block... a more aggressive
316                 // block valid so that it stays in the cache, in
482         // cache maintenance operation, restore its flag.
485         // This was a cache clean operation (without invalidate)
494         // response is not a cache invalidate, we promote targets that
559         // A cache clean opearation is looking for a dirty
583     // to pollute the cache in atomic mode since there is no bandwidth
661     // We're leaving the cache, so pop cache->name() label
903     // Occasionally this is not true... if we are a lower-level cache
916             // extract data from cache and save it into the data field in
936         // Write or WriteLine at the first cache with block in writable state
943         // this cache before knowing the store will fail.
959             // we were in the Owned state, and a cache above us that
1031                   "Should never see a write in a read-only cache %s\n",
1042         // A cache maintenance operation is always forwarded to the
1060         // encountering a Writeback generated in this cache peer cache and
1078                 // cache have the block, so we can clear the
1099     // the cache without having a writeable copy (or any copy at all).
1160             // TODO: the coherent cache can assert(!blk->isDirty());
1258         // cache, we need to update the data and the block flags
1260         // TODO: the coherent cache can assert(!blk->isDirty());
1280         // If this a write-through packet it will be sent to cache below
1327         // if we have responded to a cache, and our block is still
1328         // valid, but not dirty, and this cache is mostly exclusive
1329         // with respect to the cache above, drop the block
1359             // cache... just use temporary storage to complete the
1395         // cache) even in a read-only cache, note that we set this bit
1396         // even for a read-only cache, possibly revisit this decision
1399         // check if we got this via cache-to-cache transfer (i.e., from a
1400         // cache that had the block in Modified or Owned state)
1407                           "in read-only cache %s\n", name());
1550                   "Writeback from read-only cache");
1691         warn_once("Invalidating dirty cache lines. " \
1727     // if the cache is in write coalescing mode or (additionally) in
1735             // write a cache line
1760         // not a cache block request, but a response is expected
1772         // A cache clean opearation is looking for a dirty block. Mark
1803             // A cache clean opearation is looking for a dirty
1850         warn("*** The cache still contains dirty data. ***\n");
1853              "and dirty data in the cache will be lost!\n");
1856     // Since we don't checkpoint the data in the cache, any dirty data
1859     // cache contains dirty data.
2458     assert(!cache->system->bypassCaches());
2463     cache->recvTimingSnoopResp(pkt);
2471     if (cache->system->bypassCaches() || pkt->isExpressSnoop()) {
2488     if (cache->system->bypassCaches()) {
2491         bool M5_VAR_USED success = cache->memSidePort.sendTimingReq(pkt);
2495         cache->recvTimingReq(pkt);
2504     if (cache->system->bypassCaches()) {
2505         // Forward the request if the system is in cache bypass mode.
2506         return cache->memSidePort.sendAtomic(pkt);
2508         return cache->recvAtomic(pkt);
2515     if (cache->system->bypassCaches()) {
2516         // The cache should be flushed if we are in cache bypass mode,
2518         cache->memSidePort.sendFunctional(pkt);
2523     cache->functionalAccess(pkt, true);
2529     return cache->getAddrRanges();
2536     : CacheSlavePort(_name, _cache, _label), cache(_cache)
2548     cache->recvTimingResp(pkt);
2557     assert(!cache->system->bypassCaches());
2560     cache->recvTimingSnoopReq(pkt);
2567     assert(!cache->system->bypassCaches());
2569     return cache->recvAtomicSnoop(pkt);
2576     assert(!cache->system->bypassCaches());
2581     cache->functionalAccess(pkt, false);
2591     // queue, instead we resly on the cache to provide the packets
2596     QueueEntry* entry = cache.getNextQueueEntry();
2601         // we snoop another cache's ReadEx.
2608         waitingOnRetry = entry->sendPacket(cache);
2616         schedSendEvent(cache.nextQueueReadyTime());
2625       _snoopRespQueue(*_cache, *this, true, _label), cache(_cache)