#include "mem/cache/base_cache.hh"
#include "base/intmath.hh"
#include "mem/cache/tags/split_lifo.hh"
-#include "sim/root.hh"
+#include "sim/core.hh"
#include "base/trace.hh"
using namespace std;
SplitBlk*
-LIFOSet::findBlk(int asid, Addr tag) const
+LIFOSet::findBlk(Addr tag) const
{
for (SplitBlk *blk = firstIn; blk != NULL; blk = blk->next) {
if (blk->tag == tag && blk->isValid()) {
// probe cache for presence of given block.
bool
-SplitLIFO::probe(int asid, Addr addr) const
+SplitLIFO::probe(Addr addr) const
{
Addr tag = extractTag(addr);
unsigned myset = extractSet(addr);
- SplitBlk* blk = sets[myset].findBlk(asid, tag);
+ SplitBlk* blk = sets[myset].findBlk(tag);
return (blk != NULL);
}
SplitBlk*
-SplitLIFO::findBlock(Addr addr, int asid, int &lat)
+SplitLIFO::findBlock(Addr addr, int &lat)
{
Addr tag = extractTag(addr);
unsigned set = extractSet(addr);
- SplitBlk *blk = sets[set].findBlk(asid, tag);
+ SplitBlk *blk = sets[set].findBlk(tag);
lat = hitLatency;
return blk;
}
-SplitBlk*
-SplitLIFO::findBlock(Packet * &pkt, int &lat)
-{
- Addr addr = pkt->paddr;
- int asid = pkt->req->asid;
-
- Addr tag = extractTag(addr);
- unsigned set = extractSet(addr);
- SplitBlk *blk = sets[set].findBlk(asid, tag);
-
- if (blk) {
- DPRINTF(Split, "Found LIFO blk %#x in set %d, with tag %#x\n",
- addr, set, tag);
- hits++;
-
- if (twoQueue) {
- blk->isUsed = true;
- sets[set].moveToFirstIn(blk);
- } else {
- sets[set].moveToLastIn(blk);
- }
- }
- lat = hitLatency;
-
- return blk;
-}
SplitBlk*
-SplitLIFO::findBlock(Addr addr, int asid) const
+SplitLIFO::findBlock(Addr addr) const
{
Addr tag = extractTag(addr);
unsigned set = extractSet(addr);
- SplitBlk *blk = sets[set].findBlk(asid, tag);
+ SplitBlk *blk = sets[set].findBlk(tag);
return blk;
}
SplitBlk*
-SplitLIFO::findReplacement(Packet * &pkt, PacketList* &writebacks,
- BlkList &compress_blocks)
+SplitLIFO::findReplacement(Addr addr, PacketList &writebacks)
{
- unsigned set = extractSet(pkt->paddr);
+ unsigned set = extractSet(addr);
SplitBlk *firstIn = sets[set].firstIn;
SplitBlk *lastIn = sets[set].lastIn;
}
DPRINTF(Split, "just assigned %#x addr into LIFO, replacing %#x status %#x\n",
- pkt->paddr, regenerateBlkAddr(blk->tag, set), blk->status);
+ addr, regenerateBlkAddr(blk->tag, set), blk->status);
if (blk->isValid()) {
- int thread_num = (blk->xc) ? blk->xc->getThreadNum() : 0;
- replacements[thread_num]++;
+ replacements[0]++;
totalRefs += blk->refCount;
++sampledRefs;
blk->refCount = 0;
}
void
-SplitLIFO::invalidateBlk(int asid, Addr addr)
+SplitLIFO::invalidateBlk(SplitLIFO::BlkType *blk)
{
- SplitBlk *blk = findBlock(addr, asid);
if (blk) {
blk->status = 0;
blk->isTouched = false;
}
}
-void
-SplitLIFO::doCopy(Addr source, Addr dest, int asid, PacketList* &writebacks)
-{
- assert(source == blkAlign(source));
- assert(dest == blkAlign(dest));
- SplitBlk *source_blk = findBlock(source, asid);
- assert(source_blk);
- SplitBlk *dest_blk = findBlock(dest, asid);
- if (dest_blk == NULL) {
- // Need to do a replacement
- Packet * pkt = new Packet();
- pkt->paddr = dest;
- BlkList dummy_list;
- dest_blk = findReplacement(pkt, writebacks, dummy_list);
- if (dest_blk->isValid() && dest_blk->isModified()) {
- // Need to writeback data.
- pkt = buildWritebackReq(regenerateBlkAddr(dest_blk->tag,
- dest_blk->set),
- dest_blk->req->asid,
- dest_blk->xc,
- blkSize,
- (cache->doData())?dest_blk->data:0,
- dest_blk->size);
- writebacks.push_back(pkt);
- }
- dest_blk->tag = extractTag(dest);
- dest_blk->req->asid = asid;
- /**
- * @todo Do we need to pass in the execution context, or can we
- * assume its the same?
- */
- assert(source_blk->xc);
- dest_blk->xc = source_blk->xc;
- }
- /**
- * @todo Can't assume the status once we have coherence on copies.
- */
-
- // Set this block as readable, writeable, and dirty.
- dest_blk->status = 7;
- if (cache->doData()) {
- memcpy(dest_blk->data, source_blk->data, blkSize);
- }
-}
-
void
SplitLIFO::cleanupRefs()
{