/*
- * Copyright (c) 2018 Inria
+ * Copyright (c) 2018, 2020 Inria
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- * Authors: Daniel Carvalho
*/
/**
#include "base/intmath.hh"
#include "base/logging.hh"
#include "base/types.hh"
-#include "debug/CacheRepl.hh"
#include "mem/cache/base.hh"
#include "mem/cache/replacement_policies/base.hh"
+#include "mem/cache/replacement_policies/replaceable_entry.hh"
#include "mem/cache/tags/indexing_policies/base.hh"
-SectorTags::SectorTags(const SectorTagsParams *p)
- : BaseTags(p), allocAssoc(p->assoc),
- sequentialAccess(p->sequential_access),
- replacementPolicy(p->replacement_policy),
- numBlocksPerSector(p->num_blocks_per_sector),
- numSectors(numBlocks / p->num_blocks_per_sector), blks(numBlocks),
- secBlks(numSectors), sectorShift(floorLog2(blkSize)),
- sectorMask(numBlocksPerSector - 1)
+SectorTags::SectorTags(const SectorTagsParams &p)
+ : BaseTags(p), allocAssoc(p.assoc),
+ sequentialAccess(p.sequential_access),
+ replacementPolicy(p.replacement_policy),
+ numBlocksPerSector(p.num_blocks_per_sector),
+ numSectors(numBlocks / numBlocksPerSector),
+ sectorShift(floorLog2(blkSize)), sectorMask(numBlocksPerSector - 1),
+ sectorStats(stats, *this)
{
+ // There must be a indexing policy
+ fatal_if(!p.indexing_policy, "An indexing policy is required");
+
// Check parameters
fatal_if(blkSize < 4 || !isPowerOf2(blkSize),
"Block size must be at least 4 and a power of 2");
}
void
-SectorTags::init(BaseCache* cache)
+SectorTags::tagsInit()
{
- // Set parent cache
- setCache(cache);
+ // Create blocks and sector blocks
+ blks = std::vector<SectorSubBlk>(numBlocks);
+ secBlks = std::vector<SectorBlk>(numSectors);
// Initialize all blocks
unsigned blk_index = 0; // index into blks array
// Locate next cache sector
SectorBlk* sec_blk = &secBlks[sec_blk_index];
- // Link block to indexing policy
- indexingPolicy->setEntry(sec_blk, sec_blk_index);
-
// Associate a replacement data entry to the sector
sec_blk->replacementData = replacementPolicy->instantiateEntry();
// Update block index
++blk_index;
}
+
+ // Link block to indexing policy
+ indexingPolicy->setEntry(sec_blk, sec_blk_index);
}
}
// in the sector.
if (!sector_blk->isValid()) {
// Decrease the number of tags in use
- tagsInUse--;
+ stats.tagsInUse--;
+ assert(stats.tagsInUse.value() >= 0);
// Invalidate replacement data, as we're invalidating the sector
replacementPolicy->invalidate(sector_blk->replacementData);
// Access all tags in parallel, hence one in each way. The data side
// either accesses all blocks in parallel, or one block sequentially on
// a hit. Sequential access with a miss doesn't access data.
- tagAccesses += allocAssoc;
+ stats.tagAccesses += allocAssoc;
if (sequentialAccess) {
if (blk != nullptr) {
- dataAccesses += 1;
+ stats.dataAccesses += 1;
}
} else {
- dataAccesses += allocAssoc*numBlocksPerSector;
+ stats.dataAccesses += allocAssoc*numBlocksPerSector;
}
+ // If a cache hit
if (blk != nullptr) {
- // If a cache hit
- lat = accessLatency;
- // Check if the block to be accessed is available. If not,
- // apply the accessLatency on top of block->whenReady.
- if (blk->whenReady > curTick() &&
- cache->ticksToCycles(blk->whenReady - curTick()) >
- accessLatency) {
- lat = cache->ticksToCycles(blk->whenReady - curTick()) +
- accessLatency;
- }
-
// Update number of references to accessed block
- blk->refCount++;
+ blk->increaseRefCount();
// Get block's sector
SectorSubBlk* sub_blk = static_cast<SectorSubBlk*>(blk);
// Update replacement data of accessed block, which is shared with
// the whole sector it belongs to
replacementPolicy->touch(sector_blk->replacementData);
- } else {
- // If a cache miss
- lat = lookupLatency;
}
+ // The tag lookup latency is the same for a hit or a miss
+ lat = lookupLatency;
+
return blk;
}
void
-SectorTags::insertBlock(const Addr addr, const bool is_secure,
- const int src_master_ID, const uint32_t task_ID,
- CacheBlk *blk)
+SectorTags::insertBlock(const PacketPtr pkt, CacheBlk *blk)
{
- // Do common block insertion functionality
- BaseTags::insertBlock(addr, is_secure, src_master_ID, task_ID, blk);
-
// Get block's sector
SectorSubBlk* sub_blk = static_cast<SectorSubBlk*>(blk);
const SectorBlk* sector_blk = sub_blk->getSectorBlock();
// When a block is inserted, the tag is only a newly used tag if the
// sector was not previously present in the cache.
- // This assumes BaseTags::insertBlock does not set the valid bit.
if (sector_blk->isValid()) {
// An existing entry's replacement data is just updated
replacementPolicy->touch(sector_blk->replacementData);
} else {
// Increment tag counter
- tagsInUse++;
+ stats.tagsInUse++;
+ assert(stats.tagsInUse.value() <= numSectors);
// A new entry resets the replacement data
replacementPolicy->reset(sector_blk->replacementData);
}
+
+ // Do common block insertion functionality
+ BaseTags::insertBlock(pkt, blk);
+}
+
+void
+SectorTags::moveBlock(CacheBlk *src_blk, CacheBlk *dest_blk)
+{
+ const bool dest_was_valid =
+ static_cast<SectorSubBlk*>(dest_blk)->getSectorBlock()->isValid();
+
+ BaseTags::moveBlock(src_blk, dest_blk);
+
+ // Get blocks' sectors. The blocks have effectively been swapped by now,
+ // so src points to an invalid block, and dest to the moved valid one.
+ SectorSubBlk* src_sub_blk = static_cast<SectorSubBlk*>(src_blk);
+ const SectorBlk* src_sector_blk = src_sub_blk->getSectorBlock();
+ SectorSubBlk* dest_sub_blk = static_cast<SectorSubBlk*>(dest_blk);
+ const SectorBlk* dest_sector_blk = dest_sub_blk->getSectorBlock();
+
+ // Since the blocks were using different replacement data pointers,
+ // we must touch the replacement data of the new entry, and invalidate
+ // the one that is being moved.
+ // When a block in a sector is invalidated, it does not make the tag
+ // invalid automatically, as there might be other blocks in the sector
+ // using it. The tag is invalidated only when there is a single block
+ // in the sector.
+ if (!src_sector_blk->isValid()) {
+ // Invalidate replacement data, as we're invalidating the sector
+ replacementPolicy->invalidate(src_sector_blk->replacementData);
+
+ if (dest_was_valid) {
+ // If destination sector was valid, and the source sector became
+ // invalid, there is one less tag being used
+ stats.tagsInUse--;
+ assert(stats.tagsInUse.value() >= 0);
+ }
+ } else if (!dest_was_valid) {
+ // If destination sector was invalid and became valid, and the source
+ // sector is still valid, there is one extra tag being used
+ stats.tagsInUse++;
+ assert(stats.tagsInUse.value() <= numSectors);
+ }
+
+ if (dest_was_valid) {
+ replacementPolicy->touch(dest_sector_blk->replacementData);
+ } else {
+ replacementPolicy->reset(dest_sector_blk->replacementData);
+ }
}
CacheBlk*
// Search for block
for (const auto& sector : entries) {
auto blk = static_cast<SectorBlk*>(sector)->blks[offset];
- if (blk->getTag() == tag && blk->isValid() &&
- blk->isSecure() == is_secure) {
+ if (blk->matchTag(tag, is_secure)) {
return blk;
}
}
}
CacheBlk*
-SectorTags::findVictim(Addr addr, const bool is_secure,
- std::vector<CacheBlk*>& evict_blks) const
+SectorTags::findVictim(Addr addr, const bool is_secure, const std::size_t size,
+ std::vector<CacheBlk*>& evict_blks)
{
// Get possible entries to be victimized
const std::vector<ReplaceableEntry*> sector_entries =
SectorBlk* victim_sector = nullptr;
for (const auto& sector : sector_entries) {
SectorBlk* sector_blk = static_cast<SectorBlk*>(sector);
- if ((tag == sector_blk->getTag()) && sector_blk->isValid() &&
- (is_secure == sector_blk->isSecure())){
+ if (sector_blk->matchTag(tag, is_secure)) {
victim_sector = sector_blk;
break;
}
// Get evicted blocks. Blocks are only evicted if the sectors mismatch and
// the currently existing sector is valid.
- if ((tag == victim_sector->getTag()) &&
- (is_secure == victim_sector->isSecure())){
+ if (victim_sector->matchTag(tag, is_secure)) {
// It would be a hit if victim was valid, and upgrades do not call
// findVictim, so it cannot happen
assert(!victim->isValid());
} else {
// The whole sector must be evicted to make room for the new sector
for (const auto& blk : victim_sector->blks){
- evict_blks.push_back(blk);
+ if (blk->isValid()) {
+ evict_blks.push_back(blk);
+ }
}
}
- DPRINTF(CacheRepl, "set %x, way %x, sector offset %x: selecting blk " \
- "for replacement\n", victim->getSet(), victim->getWay(),
- victim->getSectorOffset());
+ // Update number of sub-blocks evicted due to a replacement
+ sectorStats.evictionsReplacement[evict_blks.size()]++;
return victim;
}
{
const SectorSubBlk* blk_cast = static_cast<const SectorSubBlk*>(blk);
const SectorBlk* sec_blk = blk_cast->getSectorBlock();
- const Addr sec_addr = indexingPolicy->regenerateAddr(blk->tag, sec_blk);
+ const Addr sec_addr =
+ indexingPolicy->regenerateAddr(blk->getTag(), sec_blk);
return sec_addr | ((Addr)blk_cast->getSectorOffset() << sectorShift);
}
+SectorTags::SectorTagsStats::SectorTagsStats(BaseTagStats &base_group,
+ SectorTags& _tags)
+ : Stats::Group(&base_group), tags(_tags),
+ ADD_STAT(evictionsReplacement, UNIT_COUNT,
+ "Number of blocks evicted due to a replacement")
+{
+}
+
+void
+SectorTags::SectorTagsStats::regStats()
+{
+ Stats::Group::regStats();
+
+ evictionsReplacement.init(tags.numBlocksPerSector + 1);
+ for (unsigned i = 0; i <= tags.numBlocksPerSector; ++i) {
+ evictionsReplacement.subname(i, std::to_string(i));
+ evictionsReplacement.subdesc(i, "Number of replacements that caused " \
+ "the eviction of " + std::to_string(i) + " blocks");
+ }
+}
+
void
SectorTags::forEachBlk(std::function<void(CacheBlk &)> visitor)
{
}
return false;
}
-
-SectorTags *
-SectorTagsParams::create()
-{
- // There must be a indexing policy
- fatal_if(!indexing_policy, "An indexing policy is required");
-
- return new SectorTags(this);
-}
projects / gem5.git / blobdiff