Merge zizzer:/z/m5/Bitkeeper/newmem

into  zizzer.eecs.umich.edu:/.automount/zazzer/z/rdreslin/m5bk/newmem

--HG--
extra : convert_revision : 659f84c883b9992ae48f26c837983b9f8fcf18ab

src/cpu/o3/fetch_impl.hh

@@ -672,9 +672,9 @@ DefaultFetch<Impl>::doSquash(const Addr &new_PC, unsigned tid)
         assert(cacheBlocked);
         cacheBlocked = false;
         retryTid = -1;
-        retryPkt = NULL;
         delete retryPkt->req;
         delete retryPkt;
+        retryPkt = NULL;
     }
 
     fetchStatus[tid] = Squashing;

src/cpu/o3/lsq_impl.hh

@@ -71,6 +71,11 @@ template <class Impl>
 void
 LSQ<Impl>::DcachePort::recvRetry()
 {
+    if (lsq->retryTid == -1)
+    {
+        //Squashed, so drop it
+        return;
+    }
     lsq->thread[lsq->retryTid].recvRetry();
     // Speculatively clear the retry Tid.  This will get set again if
     // the LSQUnit was unable to complete its access.

src/cpu/o3/lsq_unit.hh

@@ -646,6 +646,8 @@ LSQUnit<Impl>::read(Request *req, T &data, int load_idx)
     // handle it.
     if (lsq->cacheBlocked()) {
         ++lsqCacheBlocked;
+
+        iewStage->decrWb(load_inst->seqNum);
         // There's an older load that's already going to squash.
         if (isLoadBlocked && blockedLoadSeqNum < load_inst->seqNum)
             return NoFault;

src/cpu/o3/lsq_unit_impl.hh

@@ -626,6 +626,7 @@ LSQUnit<Impl>::writebackStores()
             ++lsqCacheBlocked;
             assert(retryPkt == NULL);
             retryPkt = data_pkt;
+            lsq->setRetryTid(lsqID);
         } else {
             storePostSend(data_pkt);
         }
@@ -869,6 +870,7 @@ LSQUnit<Impl>::recvRetry()
             storePostSend(retryPkt);
             retryPkt = NULL;
             isStoreBlocked = false;
+            lsq->setRetryTid(-1);
         } else {
             // Still blocked!
             ++lsqCacheBlocked;

src/mem/cache/base_cache.cc

@@ -73,6 +73,7 @@ BaseCache::CachePort::recvTiming(Packet *pkt)
 {
     if (blocked)
     {
+        DPRINTF(Cache,"Scheduling a retry while blocked\n");
         mustSendRetry = true;
         return false;
     }
@@ -91,21 +92,63 @@ BaseCache::CachePort::recvFunctional(Packet *pkt)
     cache->doFunctionalAccess(pkt, isCpuSide);
 }
 
+void
+BaseCache::CachePort::recvRetry()
+{
+    Packet *pkt;
+
+    if (!isCpuSide)
+    {
+        pkt = cache->getPacket();
+        bool success = sendTiming(pkt);
+        DPRINTF(Cache, "Address %x was %s in sending the timing request\n",
+                pkt->getAddr(), success ? "succesful" : "unsuccesful");
+        cache->sendResult(pkt, success);
+        if (success && cache->doMasterRequest())
+        {
+            //Still more to issue, rerequest in 1 cycle
+            pkt = NULL;
+            BaseCache::CacheEvent * reqCpu = new BaseCache::CacheEvent(this);
+            reqCpu->schedule(curTick + 1);
+        }
+    }
+    else
+    {
+        pkt = cache->getCoherencePacket();
+        bool success = sendTiming(pkt);
+        if (success && cache->doSlaveRequest())
+        {
+            //Still more to issue, rerequest in 1 cycle
+            pkt = NULL;
+            BaseCache::CacheEvent * reqCpu = new BaseCache::CacheEvent(this);
+            reqCpu->schedule(curTick + 1);
+        }
+
+    }
+    return;
+}
 void
 BaseCache::CachePort::setBlocked()
 {
+    assert(!blocked);
+    DPRINTF(Cache, "Cache Blocking\n");
     blocked = true;
+    //Clear the retry flag
+    mustSendRetry = false;
 }
 
 void
 BaseCache::CachePort::clearBlocked()
 {
+    assert(blocked);
+    DPRINTF(Cache, "Cache Unblocking\n");
+    blocked = false;
     if (mustSendRetry)
     {
+        DPRINTF(Cache, "Cache Sending Retry\n");
         mustSendRetry = false;
         sendRetry();
     }
-    blocked = false;
 }
 
 BaseCache::CacheEvent::CacheEvent(CachePort *_cachePort)
@@ -128,6 +171,7 @@ BaseCache::CacheEvent::process()
     {
         if (!cachePort->isCpuSide)
         {
+            //MSHR
             pkt = cachePort->cache->getPacket();
             bool success = cachePort->sendTiming(pkt);
             DPRINTF(Cache, "Address %x was %s in sending the timing request\n",
@@ -142,11 +186,19 @@ BaseCache::CacheEvent::process()
         }
         else
         {
+            //CSHR
             pkt = cachePort->cache->getCoherencePacket();
-            cachePort->sendTiming(pkt);
+            bool success = cachePort->sendTiming(pkt);
+            if (success && cachePort->cache->doSlaveRequest())
+            {
+                //Still more to issue, rerequest in 1 cycle
+                pkt = NULL;
+                this->schedule(curTick+1);
+            }
         }
         return;
     }
+    //Response
     //Know the packet to send, no need to mark in service (must succed)
     bool success = cachePort->sendTiming(pkt);
     assert(success);

src/mem/cache/base_cache.hh

@@ -98,6 +98,8 @@ class BaseCache : public MemObject
 
         virtual int deviceBlockSize();
 
+        virtual void recvRetry();
+
       public:
         void setBlocked();
 
@@ -407,17 +409,23 @@ class BaseCache : public MemObject
     void clearBlocked(BlockedCause cause)
     {
         uint8_t flag = 1 << cause;
-        blocked &= ~flag;
-        blockedSnoop &= ~flag;
         DPRINTF(Cache,"Unblocking for cause %s, causes left=%i\n",
                 cause, blocked);
-        if (!isBlocked()) {
-            blocked_cycles[cause] += curTick - blockedCycle;
-            DPRINTF(Cache,"Unblocking from all causes\n");
-            cpuSidePort->clearBlocked();
+        if (blocked & flag)
+        {
+            blocked &= ~flag;
+            if (!isBlocked()) {
+                blocked_cycles[cause] += curTick - blockedCycle;
+                DPRINTF(Cache,"Unblocking from all causes\n");
+                cpuSidePort->clearBlocked();
+            }
         }
-        if (!isBlockedForSnoop()) {
-           memSidePort->clearBlocked();
+        if (blockedSnoop & flag)
+        {
+            blockedSnoop &= ~flag;
+            if (!isBlockedForSnoop()) {
+                memSidePort->clearBlocked();
+            }
         }
     }
 

src/mem/packet.hh

@@ -217,7 +217,7 @@ class Packet
     bool isRequest()	 { return (cmd & IsRequest)  != 0; }
     bool isResponse()	 { return (cmd & IsResponse) != 0; }
     bool needsResponse() { return (cmd & NeedsResponse) != 0; }
-    bool isInvalidate()  { return (cmd * IsInvalidate) != 0; }
+    bool isInvalidate()  { return (cmd & IsInvalidate) != 0; }
 
     bool isCacheFill() { return (flags & CACHE_LINE_FILL) != 0; }
     bool isNoAllocate() { return (flags & NO_ALLOCATE) != 0; }