i--- InclusiveMESI.cpp.orig  2010-05-18 16:45:37.000000000 -0400
+++ InclusiveMESI.cpp   2010-11-19 10:59:38.000000000 -0500
@@ -696,6 +696,7 @@
            } else if (state == State::Modified) {
                if (from_eb) {
                    evictee->state() = State::Shared;
+                   evictee->type() = MemoryMessage::EvictClean;
                } else {
                    result->setState(State::Shared);
                }
@@ -730,6 +731,7 @@
                // Check if we have a waiting upgrade, convert it to a Write if we do
                if (waiting_maf && original_miss->type() == MemoryMessage::UpgradeReq) {
                    original_miss->type() = MemoryMessage::WriteReq;
+                   result->setProtected(false);
                }

                // L1-I can reply without sending the Invalidate up
@@ -762,6 +764,23 @@
                    act.theBackTransport = transport;
                    return act;
                }
+               
+               if (from_eb && evictee->pending()){
+
+                   tracker->setNetworkTrafficRequired(true);
+                   tracker->setResponder(theNodeId);
+                   tracker->setFillLevel(theCacheLevel);
+
+                   Action act(kSend, tracker, true /*Write Fwd needs to contain data*/);
+                   if (state == State::Modified)
+                       msg->type() = MemoryMessage::FwdReplyDirty;
+                   else
+                       msg->type() = MemoryMessage::FwdReplyWritable;
+                   act.theBackMessage = true;
+                   act.theBackTransport = transport;
+                   return act;
+               }
+
                // First, wait for outstanding Read/Fetch downgrade requests
                if (!theSnoopBuffer.hasEntry(msg->address())) {

@@ -816,6 +835,7 @@
                // If we have an outstanind upgrade, change it to a write
                if (waiting_maf && original_miss->type() == MemoryMessage::UpgradeReq) {
                    original_miss->type() = MemoryMessage::WriteReq;
+                   result->setProtected(false);
                }
                // Make sure we don't have an outstanding read/fetch because that shouldn't be possibl
                DBG_Assert(!waiting_maf || original_miss->isWrite(), ( << "Received invalidate for block in " << state << " state while waiting for: " << *original_miss ));
@@ -850,6 +870,16 @@                                                                                                                                                                 
                    return act;
                }
 
+
+               if (from_eb && evictee->pending()) {
+                   Action act(kSend, tracker, false);
+                   msg->type() = MemoryMessage::InvalidateAck;
+                   act.theBackMessage = true;
+                   act.theBackTransport = transport;
+                   return act;
+               }
+
+
                // First, look for outstanding snoops, and wait for them to complete
                if (!theSnoopBuffer.hasEntry(msg->address())) {
                                                                                                                                                                      
@@ -897,6 +927,7 @@                                                                                                                                                   
                    if (original_miss->type() == MemoryMessage::UpgradeReq) {
                        DBG_Assert(state != State::Modified, ( << "Expected MAF to be Upgrade for block NOT in modified state, instead, block is " << state << " and maf is for: " << *original_miss ));
                        original_miss->type() = MemoryMessage::WriteReq;
+                       result->setProtected(false);
                    } else {
                        DBG_Assert((original_miss->type() == MemoryMessage::StoreReq) || (original_miss->type() == MemoryMessage::StorePrefetchReq) || (original_miss->type() == MemoryMessage::CmpxReq) || (original_miss->type() == MemoryMessage::RMWReq), ( << "Expected MAF to be Store/StorePrefetch/Cmpx/RMW, but instead found " << *original_miss));
                        DBG_Assert(state != State::Modified, ( << "Expected MAF to be Store for block NOT in modified state, instead, block is " << state << " and maf is for: " << *original_miss ));
@@ -932,6 +964,16 @@ 
                    return act; 
                } 
 
+ 
+               if (from_eb && evictee->pending()){ 
+                   Action act(kSend, tracker, false); 
+                   msg->type() = MemoryMessage::InvalidateAck; 
+                   act.theBackMessage = true; 
+                   act.theBackTransport = transport; 
+                   return act; 
+               } 
+ 
+ 
                // First, look for outstanding snoops, and wait for them to complete 
                if (!theSnoopBuffer.hasEntry(msg->address())) { 
 
@@ -1047,6 +1088,7 @@ 
                intrusive_ptr<MemoryMessage> reply(new MemoryMessage(MemoryMessage::WriteAck, msg->address())); 
                if (sent_upgrade) { 
                    reply->type() = MemoryMessage::UpgradeAck; 
+                   result->setProtected(false); 
                } 
                action.theBackMessage = true; 
                action.theBackTransport = transport; 
@@ -1619,6 +1679,7 @@ 
                result->setState(State::Shared); 
            } else { 
                evEntry->state() = State::Shared; 
+               evEntry->type() = MemoryMessage::EvictClean; 
            } 
 
            // We either got data back that we need to write, or we need to read it