mem/cache/base.hh

244      * addition, it has the functionality to block the port for
358      * Temporary cache block for occasional transitory use.  We use
360      * is an outstanding request that accesses the victim block) or
419      * Regenerate block address using tags.
421      * block or not.
423      * @param blk The block to regenerate address.
424      * @return The block's address.
442      * @param blk The cache block that was accessed.
445      * @return The number of ticks that pass due to a block access.
453      * @param blk The cache block to be updated.
465      * @param blk The referenced block
466      * @param request_time The tick at which the block lookup is compete
478      * @param blk The referenced block
480      * @param request_time The tick at which the block lookup is compete
492      * @param blk The referenced block
493      * @param mshr Any existing mshr for the referenced cache block
495      * @param request_time The tick at which the block lookup is compete
520      * @param blk The reference block
551      * @param blk The referenced block
612      * @param blk The referenced block, can be nullptr.
613      * @param needs_writable Indicates that the block must be writable
643      * recvAtomic finishes in cases where the block we filled is in
661      * When a block is overwriten, its compression information must be updated,
663      * block may either become smaller, in which case there is no side effect,
664      * or bigger (data expansion; fat write), in which case the block might not
668      * - The co-allocated blocks must be evicted to make room for this block.
670      * - The block itself is moved elsewhere (used in policies where the CF
671      *   determines the location of the block).
679      * @param blk The block to be overwriten.
688      * Perform any necessary updates to the block and perform any data
689      * exchange between the packet and the block. The flags of the
692      * @param pkt Request packet from upstream that hit a block
693      * @param blk Cache block that the packet hit
703      * invalidating a block. This method works in conjunction with
705      * targets before potentially dropping a block.
708      * @param blk The block that should potentially be dropped
715      * Populates a cache block and handles all outstanding requests for the
725      * @param blk The cache block if it already exists.
727      * @param allocate Whether to allocate a block or use the temp block
728      * @return Pointer to the new cache block.
734      * Allocate a new block and perform any necessary writebacks
736      * Find a victim block and if necessary prepare writebacks for any
738      * blocks. If a replaceable block is found, it inserts the new block in
739      * its place. The new block, however, is not set as valid yet.
743      * @return the allocated block
747      * Evict a cache block.
749      * Performs a writeback if necesssary and invalidates the block
757      * Evict a cache block.
759      * Performs a writeback if necesssary and invalidates the block
767      * Invalidate a cache block.
774      * Create a writeback request for the given block.
776      * @param blk The block to writeback.
777      * @return The writeback request for the block.
782      * Create a writeclean request for the given block.
784      * Creates a request that writes the block to the cache below
785      * without evicting the block from the current cache.
787      * @param blk The block to write clean.
811      * @return true if at least one block is dirty, false otherwise.
852     /** The latency to fill a cache block */
976     /** The number of times a HW-prefetched block is evicted w/o reference. */
1060      * Query block size of a cache.
1061      * @return  The block size
1096         // If using compression, on evictions the block is decompressed and
1182         CacheBlk *block = tags->findBlock(addr, is_secure);
1183         if (block) {
1184             return block->wasPrefetched();
1221      * Cache block visitor that writes back dirty cache blocks using
1227      * Cache block visitor that invalidates all blocks in the cache.
1270  * until the whole block is written at which point a single packet
1322      * @param blk_addr The block address the packet writes to
1335      * Clear delay counter for the input block
1337      * @param blk_addr The accessed cache block
1351      * @param blk_addr The block address that this packet writes to