super_blk.cc

Go to the documentation of this file.

 
#include "mem/cache/tags/super_blk.hh"
 
#include "base/logging.hh"
 
CompressionBlk::CompressionBlk()
    : SectorSubBlk(), _size(0), _decompressionLatency(0)
{
}
 
bool
CompressionBlk::isCompressed() const
{
    return (status & BlkCompressed) != 0;
}
 
void
CompressionBlk::setCompressed()
{
    status |= BlkCompressed;
}
 
void
CompressionBlk::setUncompressed()
{
    status &= ~BlkCompressed;
}
 
std::size_t
CompressionBlk::getSizeBits() const
{
    return _size;
}
 
void
CompressionBlk::setSizeBits(const std::size_t size)
{
    _size = size;
}
 
Cycles
CompressionBlk::getDecompressionLatency() const
{
    return _decompressionLatency;
}
 
void
CompressionBlk::setDecompressionLatency(const Cycles lat)
{
    _decompressionLatency = lat;
}
 
std::string
CompressionBlk::print() const
{
    return csprintf("%s compressed: %d size: %llu decompression latency: %d",
                    SectorSubBlk::print(), isCompressed(), getSizeBits(),
                    getDecompressionLatency());
}
 
bool
SuperBlk::isCompressed(const CompressionBlk* ignored_blk) const
{
    for (const auto& blk : blks) {
        if (blk->isValid() && (blk != ignored_blk)) {
            return static_cast<CompressionBlk*>(blk)->isCompressed();
        }
    }
 
    // An invalid block is seen as compressed
    return true;
}
 
bool
SuperBlk::canCoAllocate(const std::size_t compressed_size) const
{
    // Simple co-allocation function: at most numBlocksPerSector blocks that
    // compress at least to (100/numBlocksPerSector)% of their original size
    // can share a superblock
    return (compressed_size <= (blkSize * 8) / blks.size());
}
 
void
SuperBlk::setBlkSize(const std::size_t blk_size)
{
    assert(blkSize == 0);
    blkSize = blk_size;
}