ruby: fix ruby llsc support to sync sc outcomes

Added support so that ruby can determine the outcome of store conditional
operations and reflect that outcome to M5 physical memory and cpus.

4 files changed, 77 insertions, 40 deletions

diff --git a/src/mem/ruby/system/CacheMemory.cc b/src/mem/ruby/system/CacheMemory.cc
index 9102d1963..604113238 100644
--- a/src/mem/ruby/system/CacheMemory.cc
+++ b/src/mem/ruby/system/CacheMemory.cc
@@ -353,7 +353,9 @@ CacheMemory::changePermission(const Address& address,
     lookup(address).m_Permission = new_perm;
     Index cacheSet = addressToCacheSet(address);
     int loc = findTagInSet(cacheSet, address);
-    if (new_perm != AccessPermission_Read_Write) {
+    if ((new_perm == AccessPermission_Invalid) ||
+        (new_perm == AccessPermission_NotPresent) ||
+        (new_perm == AccessPermission_Stale)) {
         DPRINTF(RubyCache, "Permission clearing lock for addr: %x\n", address);
         m_locked[cacheSet][loc] = -1;
     }
diff --git a/src/mem/ruby/system/RubyPort.cc b/src/mem/ruby/system/RubyPort.cc
index 87a98185c..a8edb03b2 100644
--- a/src/mem/ruby/system/RubyPort.cc
+++ b/src/mem/ruby/system/RubyPort.cc
@@ -229,23 +229,10 @@ RubyPort::M5Port::recvTiming(PacketPtr pkt)
     // Submit the ruby request
     RequestStatus requestStatus = ruby_port->makeRequest(ruby_request);
 
-    // If the request successfully issued or the SC request completed because
-    // exclusive permission was lost, then we should return true.
+    // If the request successfully issued then we should return true.
     // Otherwise, we need to delete the senderStatus we just created and return
     // false.
-    if ((requestStatus == RequestStatus_Issued) ||
-        (requestStatus == RequestStatus_LlscFailed)) {
-
-        // The communicate to M5 whether the SC command succeeded by seting the
-        // packet's extra data.
-        if (pkt->isLLSC() && pkt->isWrite()) {
-            if (requestStatus == RequestStatus_LlscFailed) {
-                DPRINTF(MemoryAccess, "SC failed and request completed\n");
-                pkt->req->setExtraData(0);
-            } else {
-                pkt->req->setExtraData(1);
-            }
-        }
+    if (requestStatus == RequestStatus_Issued) {
         return true;
     }
 
@@ -280,9 +267,39 @@ RubyPort::M5Port::hitCallback(PacketPtr pkt)
 {
     bool needsResponse = pkt->needsResponse();
 
+    //
+    // All responses except failed SC operations access M5 physical memory
+    //
+    bool accessPhysMem = true;
+
+    if (pkt->isLLSC()) {
+        if (pkt->isWrite()) {
+            if (pkt->req->getExtraData() != 0) {
+                //
+                // Successful SC packets convert to normal writes
+                //
+                pkt->convertScToWrite();
+            } else {
+                //
+                // Failed SC packets don't access physical memory and thus
+                // the RubyPort itself must convert it to a response.
+                //
+                accessPhysMem = false;
+                pkt->makeAtomicResponse();
+            }
+        } else {
+            //
+            // All LL packets convert to normal loads so that M5 PhysMem does
+            // not lock the blocks.
+            //
+            pkt->convertLlToRead();
+        }
+    }
     DPRINTF(MemoryAccess, "Hit callback needs response %d\n", needsResponse);
 
-    ruby_port->physMemPort->sendAtomic(pkt);
+    if (accessPhysMem) {
+        ruby_port->physMemPort->sendAtomic(pkt);
+    }
 
     // turn packet around to go back to requester if response expected
     if (needsResponse) {
diff --git a/src/mem/ruby/system/Sequencer.cc b/src/mem/ruby/system/Sequencer.cc
index e4f85908f..600f95d10 100644
--- a/src/mem/ruby/system/Sequencer.cc
+++ b/src/mem/ruby/system/Sequencer.cc
@@ -41,6 +41,7 @@
 #include "mem/ruby/system/CacheMemory.hh"
 #include "mem/ruby/system/Sequencer.hh"
 #include "mem/ruby/system/System.hh"
+#include "mem/packet.hh"
 #include "params/RubySequencer.hh"
 
 using namespace std;
@@ -303,6 +304,38 @@ Sequencer::removeRequest(SequencerRequest* srequest)
 }
 
 void
+Sequencer::handleLlscWrites(const Address& address, SequencerRequest* request)
+{
+    if (request->ruby_request.type == RubyRequestType_Locked_Write) {
+        if (!m_dataCache_ptr->isLocked(address, m_version)) {
+            //
+            // For failed SC requests, indicate the failure to the cpu by
+            // setting the extra data to zero.
+            //
+            request->ruby_request.pkt->req->setExtraData(0);
+        } else {
+            //
+            // For successful SC requests, indicate the success to the cpu by
+            // setting the extra data to one.  
+            //
+            request->ruby_request.pkt->req->setExtraData(1);
+        }
+        m_dataCache_ptr->clearLocked(address);
+    } else if (request->ruby_request.type == RubyRequestType_Locked_Read) {
+        //
+        // Note: To fully follow Alpha LLSC semantics, should the LL clear any
+        // previously locked cache lines?
+        //
+        m_dataCache_ptr->setLocked(address, m_version);
+    } else if (m_dataCache_ptr->isLocked(address, m_version)) {
+        //
+        // Normal writes should clear the locked address
+        //
+        m_dataCache_ptr->clearLocked(address);
+    }
+}
+
+void
 Sequencer::writeCallback(const Address& address, DataBlock& data)
 {
     writeCallback(address, GenericMachineType_NULL, data);
@@ -329,9 +362,13 @@ Sequencer::writeCallback(const Address& address,
            (request->ruby_request.type == RubyRequestType_Locked_Read) ||
            (request->ruby_request.type == RubyRequestType_Locked_Write));
 
-    if (request->ruby_request.type == RubyRequestType_Locked_Read) {
-        m_dataCache_ptr->setLocked(address, m_version);
-    } else if (request->ruby_request.type == RubyRequestType_RMW_Read) {
+    //
+    // For Alpha, properly handle LL, SC, and write requests with respect to
+    // locked cache blocks.
+    //
+    handleLlscWrites(address, request);
+
+    if (request->ruby_request.type == RubyRequestType_RMW_Read) {
         m_controller->blockOnQueue(address, m_mandatory_q_ptr);
     } else if (request->ruby_request.type == RubyRequestType_RMW_Write) {
         m_controller->unblock(address);
@@ -504,26 +541,6 @@ Sequencer::makeRequest(const RubyRequest &request)
         return RequestStatus_NULL;
     }
 
-    if (request.type == RubyRequestType_Locked_Write) {
-        // NOTE: it is OK to check the locked flag here as the
-        // mandatory queue will be checked first ensuring that nothing
-        // comes between checking the flag and servicing the store.
-
-        Address line_addr = line_address(Address(request.paddr));
-        if (!m_dataCache_ptr->isLocked(line_addr, m_version)) {
-            removeRequest(srequest);
-            if (Debug::getProtocolTrace()) {
-                g_system_ptr->getProfiler()->
-                    profileTransition("Seq", m_version,
-                                      Address(request.paddr),
-                                      "", "SC Fail", "",
-                                      RubyRequestType_to_string(request.type));
-            }
-            return RequestStatus_LlscFailed;
-        } else {
-            m_dataCache_ptr->clearLocked(line_addr);
-        }
-    }
     issueRequest(request);
 
     // TODO: issue hardware prefetches here
diff --git a/src/mem/ruby/system/Sequencer.hh b/src/mem/ruby/system/Sequencer.hh
index fd6b390c2..c298e27dd 100644
--- a/src/mem/ruby/system/Sequencer.hh
+++ b/src/mem/ruby/system/Sequencer.hh
@@ -109,6 +109,7 @@ class Sequencer : public RubyPort, public Consumer
 
     bool insertRequest(SequencerRequest* request);
 
+    void handleLlscWrites(const Address& address, SequencerRequest* request);
 
     // Private copy constructor and assignment operator
     Sequencer(const Sequencer& obj);