A few minor non-debug compilation issues.

[gem5.git] / src / mem / cache / tags / split_lifo.cc

diff --git a/src/mem/cache/tags/split_lifo.cc b/src/mem/cache/tags/split_lifo.cc
index f6493fdd2804a5f93c7db82782c723eab744ada0..4ee2473a44be60af0a3c991ddd0a014cac164701 100644 (file)
--- a/src/mem/cache/tags/split_lifo.cc
+++ b/src/mem/cache/tags/split_lifo.cc
@@ -38,13 +38,13 @@
 #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()) {
@@ -216,21 +216,21 @@ SplitLIFO::regStats(const std::string &name)
 
 // 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;
 
@@ -254,48 +254,21 @@ SplitLIFO::findBlock(Addr addr, int asid, int &lat)
     return blk;
 }
 
-SplitBlk*
-SplitLIFO::findBlock(Packet * &pkt, int &lat)
-{
-    Addr addr = pkt->getAddr();
-    int asid = pkt->req->getAsid();
-
-    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->getAddr());
+    unsigned set = extractSet(addr);
 
     SplitBlk *firstIn = sets[set].firstIn;
     SplitBlk *lastIn = sets[set].lastIn;
@@ -315,7 +288,7 @@ SplitLIFO::findReplacement(Packet * &pkt, PacketList &writebacks,
     }
 
     DPRINTF(Split, "just assigned %#x addr into LIFO, replacing %#x status %#x\n",
-            pkt->getAddr(), regenerateBlkAddr(blk->tag, set), blk->status);
+            addr, regenerateBlkAddr(blk->tag, set), blk->status);
     if (blk->isValid()) {
         replacements[0]++;
         totalRefs += blk->refCount;
@@ -336,9 +309,8 @@ SplitLIFO::findReplacement(Packet * &pkt, PacketList &writebacks,
 }
 
 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;
@@ -347,54 +319,6 @@ SplitLIFO::invalidateBlk(int asid, Addr addr)
     }
 }
 
-void
-SplitLIFO::doCopy(Addr source, Addr dest, int asid, PacketList &writebacks)
-{
-//Copy Unsuported for now
-#if 0
-    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);
-    }
-#endif
-}
-
 void
 SplitLIFO::cleanupRefs()
 {