ruby: restrict Address to being a type and not a variable name

Change all occurrances of Address as a variable name to instead use Addr.
Address is an allowed name in slicc even when Address is also being used as a
type, leading to declarations of "Address Address". While this works, it
prevents adding another field of type Address because the compiler then thinks
Address is a variable name, not type.

Committed by: Nilay Vaish <nilay@cs.wisc.edu>

1 files changed, 66 insertions, 66 deletions

diff --git a/src/mem/protocol/MOESI_CMP_token-L2cache.sm b/src/mem/protocol/MOESI_CMP_token-L2cache.sm
index 60a9f699b..c7b2a618d 100644
--- a/src/mem/protocol/MOESI_CMP_token-L2cache.sm
+++ b/src/mem/protocol/MOESI_CMP_token-L2cache.sm
@@ -306,33 +306,33 @@ machine(L2Cache, "Token protocol")
         assert(in_msg.Destination.isElement(machineID));
 
         if (in_msg.Type == PersistentRequestType:GETX_PERSISTENT) {
-          persistentTable.persistentRequestLock(in_msg.Address, in_msg.Requestor, AccessType:Write);
+          persistentTable.persistentRequestLock(in_msg.Addr, in_msg.Requestor, AccessType:Write);
         } else if (in_msg.Type == PersistentRequestType:GETS_PERSISTENT) {
-          persistentTable.persistentRequestLock(in_msg.Address, in_msg.Requestor, AccessType:Read);
+          persistentTable.persistentRequestLock(in_msg.Addr, in_msg.Requestor, AccessType:Read);
         } else if (in_msg.Type == PersistentRequestType:DEACTIVATE_PERSISTENT) {
-          persistentTable.persistentRequestUnlock(in_msg.Address, in_msg.Requestor);
+          persistentTable.persistentRequestUnlock(in_msg.Addr, in_msg.Requestor);
         } else {
           error("Unexpected message");
         }
 
-        Entry cache_entry := getCacheEntry(in_msg.Address);
+        Entry cache_entry := getCacheEntry(in_msg.Addr);
         // React to the message based on the current state of the table
-        if (persistentTable.isLocked(in_msg.Address)) {
+        if (persistentTable.isLocked(in_msg.Addr)) {
 
-          if (persistentTable.typeOfSmallest(in_msg.Address) == AccessType:Read) {
+          if (persistentTable.typeOfSmallest(in_msg.Addr) == AccessType:Read) {
             if (getTokens(cache_entry) == 1 ||
                 getTokens(cache_entry) == (max_tokens() / 2) + 1) {
-              trigger(Event:Persistent_GETS_Last_Token, in_msg.Address,
+              trigger(Event:Persistent_GETS_Last_Token, in_msg.Addr,
                       cache_entry);
             } else {
-              trigger(Event:Persistent_GETS, in_msg.Address, cache_entry);
+              trigger(Event:Persistent_GETS, in_msg.Addr, cache_entry);
             }
           } else {
-            trigger(Event:Persistent_GETX, in_msg.Address, cache_entry);
+            trigger(Event:Persistent_GETX, in_msg.Addr, cache_entry);
           }
         }
         else {
-            trigger(Event:Own_Lock_or_Unlock, in_msg.Address, cache_entry);
+            trigger(Event:Own_Lock_or_Unlock, in_msg.Addr, cache_entry);
         }
       }
     }
@@ -345,16 +345,16 @@ machine(L2Cache, "Token protocol")
       peek(requestNetwork_in, RequestMsg) {
         assert(in_msg.Destination.isElement(machineID));
 
-        Entry cache_entry := getCacheEntry(in_msg.Address);
+        Entry cache_entry := getCacheEntry(in_msg.Addr);
         if (in_msg.Type == CoherenceRequestType:GETX) {
-            trigger(Event:Transient_GETX, in_msg.Address, cache_entry);
+            trigger(Event:Transient_GETX, in_msg.Addr, cache_entry);
         } else if (in_msg.Type == CoherenceRequestType:GETS) {
           if (getTokens(cache_entry) == 1) {
-            trigger(Event:Transient_GETS_Last_Token, in_msg.Address,
+            trigger(Event:Transient_GETS_Last_Token, in_msg.Addr,
                     cache_entry);
           }
           else {
-            trigger(Event:Transient_GETS, in_msg.Address, cache_entry);
+            trigger(Event:Transient_GETS, in_msg.Addr, cache_entry);
           }
         } else {
           error("Unexpected message");
@@ -367,16 +367,16 @@ machine(L2Cache, "Token protocol")
     if (L1requestNetwork_in.isReady()) {
       peek(L1requestNetwork_in, RequestMsg) {
         assert(in_msg.Destination.isElement(machineID));
-        Entry cache_entry := getCacheEntry(in_msg.Address);
+        Entry cache_entry := getCacheEntry(in_msg.Addr);
         if (in_msg.Type == CoherenceRequestType:GETX) {
-          trigger(Event:L1_GETX, in_msg.Address, cache_entry);
+          trigger(Event:L1_GETX, in_msg.Addr, cache_entry);
         } else if (in_msg.Type == CoherenceRequestType:GETS) {
           if (getTokens(cache_entry) == 1 ||
               getTokens(cache_entry) == (max_tokens() / 2) + 1) {
-            trigger(Event:L1_GETS_Last_Token, in_msg.Address, cache_entry);
+            trigger(Event:L1_GETS_Last_Token, in_msg.Addr, cache_entry);
           }
           else {
-            trigger(Event:L1_GETS, in_msg.Address, cache_entry);
+            trigger(Event:L1_GETS, in_msg.Addr, cache_entry);
           }
         } else {
           error("Unexpected message");
@@ -391,80 +391,80 @@ machine(L2Cache, "Token protocol")
     if (responseNetwork_in.isReady()) {
       peek(responseNetwork_in, ResponseMsg) {
         assert(in_msg.Destination.isElement(machineID));
-        Entry cache_entry := getCacheEntry(in_msg.Address);
+        Entry cache_entry := getCacheEntry(in_msg.Addr);
 
         if (getTokens(cache_entry) + in_msg.Tokens != max_tokens()) {
           if (in_msg.Type == CoherenceResponseType:ACK) {
             assert(in_msg.Tokens < (max_tokens() / 2));
-            trigger(Event:Ack, in_msg.Address, cache_entry);
+            trigger(Event:Ack, in_msg.Addr, cache_entry);
           } else if (in_msg.Type == CoherenceResponseType:DATA_OWNER) {
-            trigger(Event:Data_Owner, in_msg.Address, cache_entry);
+            trigger(Event:Data_Owner, in_msg.Addr, cache_entry);
           } else if (in_msg.Type == CoherenceResponseType:DATA_SHARED) {
-            trigger(Event:Data_Shared, in_msg.Address, cache_entry);
+            trigger(Event:Data_Shared, in_msg.Addr, cache_entry);
           } else if (in_msg.Type == CoherenceResponseType:WB_TOKENS ||
                      in_msg.Type == CoherenceResponseType:WB_OWNED ||
                      in_msg.Type == CoherenceResponseType:WB_SHARED_DATA) {
 
-            if (L2cache.cacheAvail(in_msg.Address) || is_valid(cache_entry)) {
+            if (L2cache.cacheAvail(in_msg.Addr) || is_valid(cache_entry)) {
 
               // either room is available or the block is already present
 
               if (in_msg.Type == CoherenceResponseType:WB_TOKENS) {
                 assert(in_msg.Dirty == false);
-                trigger(Event:Writeback_Tokens, in_msg.Address, cache_entry);
+                trigger(Event:Writeback_Tokens, in_msg.Addr, cache_entry);
               } else if (in_msg.Type == CoherenceResponseType:WB_SHARED_DATA) {
                 assert(in_msg.Dirty == false);
-                trigger(Event:Writeback_Shared_Data, in_msg.Address, cache_entry);
+                trigger(Event:Writeback_Shared_Data, in_msg.Addr, cache_entry);
               }
               else if (in_msg.Type == CoherenceResponseType:WB_OWNED) {
                 //assert(in_msg.Dirty == false);
-                trigger(Event:Writeback_Owned, in_msg.Address, cache_entry);
+                trigger(Event:Writeback_Owned, in_msg.Addr, cache_entry);
               }
             }
             else {
                 trigger(Event:L2_Replacement,
-                        L2cache.cacheProbe(in_msg.Address),
-                        getCacheEntry(L2cache.cacheProbe(in_msg.Address)));
+                        L2cache.cacheProbe(in_msg.Addr),
+                        getCacheEntry(L2cache.cacheProbe(in_msg.Addr)));
             }
           } else if (in_msg.Type == CoherenceResponseType:INV) {
-            trigger(Event:L1_INV, in_msg.Address, cache_entry);
+            trigger(Event:L1_INV, in_msg.Addr, cache_entry);
           } else {
             error("Unexpected message");
           }
         } else {
           if (in_msg.Type == CoherenceResponseType:ACK) {
             assert(in_msg.Tokens < (max_tokens() / 2));
-            trigger(Event:Ack_All_Tokens, in_msg.Address, cache_entry);
+            trigger(Event:Ack_All_Tokens, in_msg.Addr, cache_entry);
           } else if (in_msg.Type == CoherenceResponseType:DATA_OWNER ||
                      in_msg.Type == CoherenceResponseType:DATA_SHARED) {
-            trigger(Event:Data_All_Tokens, in_msg.Address, cache_entry);
+            trigger(Event:Data_All_Tokens, in_msg.Addr, cache_entry);
           } else if (in_msg.Type == CoherenceResponseType:WB_TOKENS ||
                      in_msg.Type == CoherenceResponseType:WB_OWNED ||
                      in_msg.Type == CoherenceResponseType:WB_SHARED_DATA) {
-            if (L2cache.cacheAvail(in_msg.Address) || is_valid(cache_entry)) {
+            if (L2cache.cacheAvail(in_msg.Addr) || is_valid(cache_entry)) {
 
               // either room is available or the block is already present
 
               if (in_msg.Type == CoherenceResponseType:WB_TOKENS) {
                 assert(in_msg.Dirty == false);
-                assert(  (getState(cache_entry, in_msg.Address) != State:NP)
-                      && (getState(cache_entry, in_msg.Address) != State:I) );
-                trigger(Event:Writeback_All_Tokens, in_msg.Address, cache_entry);
+                assert(  (getState(cache_entry, in_msg.Addr) != State:NP)
+                      && (getState(cache_entry, in_msg.Addr) != State:I) );
+                trigger(Event:Writeback_All_Tokens, in_msg.Addr, cache_entry);
               } else if (in_msg.Type == CoherenceResponseType:WB_SHARED_DATA) {
                 assert(in_msg.Dirty == false);
-                trigger(Event:Writeback_All_Tokens, in_msg.Address, cache_entry);
+                trigger(Event:Writeback_All_Tokens, in_msg.Addr, cache_entry);
               }
               else if (in_msg.Type == CoherenceResponseType:WB_OWNED) {
-                trigger(Event:Writeback_All_Tokens, in_msg.Address, cache_entry);
+                trigger(Event:Writeback_All_Tokens, in_msg.Addr, cache_entry);
               }
             }
             else {
                 trigger(Event:L2_Replacement,
-                        L2cache.cacheProbe(in_msg.Address),
-                        getCacheEntry(L2cache.cacheProbe(in_msg.Address)));
+                        L2cache.cacheProbe(in_msg.Addr),
+                        getCacheEntry(L2cache.cacheProbe(in_msg.Addr)));
             }
           } else if (in_msg.Type == CoherenceResponseType:INV) {
-            trigger(Event:L1_INV, in_msg.Address, cache_entry);
+            trigger(Event:L1_INV, in_msg.Addr, cache_entry);
           } else {
             DPRINTF(RubySlicc, "%s\n", in_msg.Type);
             error("Unexpected message");
@@ -483,9 +483,9 @@ machine(L2Cache, "Token protocol")
 
      // if this is a retry or no local sharers, broadcast normally
 
-     // if (in_msg.RetryNum > 0 || (in_msg.Type == CoherenceRequestType:GETX && exclusiveExists(in_msg.Address) == false) || (in_msg.Type == CoherenceRequestType:GETS && sharersExist(in_msg.Address) == false)) {
+     // if (in_msg.RetryNum > 0 || (in_msg.Type == CoherenceRequestType:GETX && exclusiveExists(in_msg.Addr) == false) || (in_msg.Type == CoherenceRequestType:GETS && sharersExist(in_msg.Addr) == false)) {
         enqueue(globalRequestNetwork_out, RequestMsg, latency=l2_request_latency) {
-           out_msg.Address := in_msg.Address;
+           out_msg.Addr := in_msg.Addr;
            out_msg.Type := in_msg.Type;
            out_msg.Requestor := in_msg.Requestor;
            out_msg.RetryNum := in_msg.RetryNum;
@@ -514,7 +514,7 @@ machine(L2Cache, "Token protocol")
     peek(responseNetwork_in, ResponseMsg) {
       // FIXME, should use a 3rd vnet
       enqueue(responseNetwork_out, ResponseMsg, latency="1") {
-        out_msg.Address := address;
+        out_msg.Addr := address;
         out_msg.Type := in_msg.Type;
         out_msg.Sender := machineID;
         out_msg.Destination.add(map_Address_to_Directory(address));
@@ -530,7 +530,7 @@ machine(L2Cache, "Token protocol")
     assert(is_valid(cache_entry));
     if (cache_entry.Tokens > 0) {
       enqueue(responseNetwork_out, ResponseMsg, latency=l2_response_latency) {
-        out_msg.Address := address;
+        out_msg.Addr := address;
         out_msg.Type := CoherenceResponseType:ACK;
         out_msg.Sender := machineID;
         out_msg.Destination.add(map_Address_to_Directory(address));
@@ -544,7 +544,7 @@ machine(L2Cache, "Token protocol")
   action(cc_dirtyReplacement, "\c", desc="Issue dirty writeback") {
     assert(is_valid(cache_entry));
     enqueue(responseNetwork_out, ResponseMsg, latency=l2_response_latency) {
-      out_msg.Address := address;
+      out_msg.Addr := address;
       out_msg.Sender := machineID;
       out_msg.Destination.add(map_Address_to_Directory(address));
       out_msg.Tokens := cache_entry.Tokens;
@@ -567,7 +567,7 @@ machine(L2Cache, "Token protocol")
       assert(is_valid(cache_entry));
       if (cache_entry.Tokens > (N_tokens + (max_tokens() / 2))) {
         enqueue(responseNetwork_out, ResponseMsg, latency=l2_response_latency) {
-          out_msg.Address := address;
+          out_msg.Addr := address;
           out_msg.Type := CoherenceResponseType:DATA_SHARED;
           out_msg.Sender := machineID;
           out_msg.Destination.add(in_msg.Requestor);
@@ -580,7 +580,7 @@ machine(L2Cache, "Token protocol")
       }
       else {
         enqueue(responseNetwork_out, ResponseMsg, latency=l2_response_latency) {
-          out_msg.Address := address;
+          out_msg.Addr := address;
           out_msg.Type := CoherenceResponseType:DATA_SHARED;
           out_msg.Sender := machineID;
           out_msg.Destination.add(in_msg.Requestor);
@@ -598,7 +598,7 @@ machine(L2Cache, "Token protocol")
     assert(is_valid(cache_entry));
     peek(requestNetwork_in, RequestMsg) {
       enqueue(responseNetwork_out, ResponseMsg, latency=l2_response_latency) {
-        out_msg.Address := address;
+        out_msg.Addr := address;
         out_msg.Type := CoherenceResponseType:DATA_OWNER;
         out_msg.Sender := machineID;
         out_msg.Destination.add(in_msg.Requestor);
@@ -616,7 +616,7 @@ machine(L2Cache, "Token protocol")
     assert(is_valid(cache_entry));
     if (cache_entry.Tokens > 0) {
       enqueue(responseNetwork_out, ResponseMsg, latency=l2_response_latency) {
-        out_msg.Address := address;
+        out_msg.Addr := address;
         out_msg.Type := CoherenceResponseType:ACK;
         out_msg.Sender := machineID;
         out_msg.Destination.add(persistentTable.findSmallest(address));
@@ -631,7 +631,7 @@ machine(L2Cache, "Token protocol")
   action(ee_sendDataWithAllTokens, "\e", desc="Send data and all tokens from cache to starver") {
     assert(is_valid(cache_entry));
     enqueue(responseNetwork_out, ResponseMsg, latency=l2_response_latency) {
-      out_msg.Address := address;
+      out_msg.Addr := address;
       out_msg.Type := CoherenceResponseType:DATA_OWNER;
       out_msg.Sender := machineID;
       out_msg.Destination.add(persistentTable.findSmallest(address));
@@ -650,7 +650,7 @@ machine(L2Cache, "Token protocol")
     assert(cache_entry.Tokens > 0);
     if (cache_entry.Tokens > 1) {
       enqueue(responseNetwork_out, ResponseMsg, latency=l2_response_latency) {
-        out_msg.Address := address;
+        out_msg.Addr := address;
         out_msg.Type := CoherenceResponseType:ACK;
         out_msg.Sender := machineID;
         out_msg.Destination.add(persistentTable.findSmallest(address));
@@ -667,7 +667,7 @@ machine(L2Cache, "Token protocol")
     assert(is_valid(cache_entry));
     assert(cache_entry.Tokens > (max_tokens() / 2) + 1);
     enqueue(responseNetwork_out, ResponseMsg, latency=l2_response_latency) {
-        out_msg.Address := address;
+        out_msg.Addr := address;
         out_msg.Type := CoherenceResponseType:DATA_OWNER;
         out_msg.Sender := machineID;
         out_msg.Destination.add(persistentTable.findSmallest(address));
@@ -684,7 +684,7 @@ machine(L2Cache, "Token protocol")
     assert(is_valid(cache_entry));
     assert(cache_entry.Tokens == (max_tokens() / 2) + 1);
     enqueue(responseNetwork_out, ResponseMsg, latency=l2_response_latency) {
-        out_msg.Address := address;
+        out_msg.Addr := address;
         out_msg.Type := CoherenceResponseType:DATA_OWNER;
         out_msg.Sender := machineID;
         out_msg.Destination.add(persistentTable.findSmallest(address));
@@ -703,7 +703,7 @@ machine(L2Cache, "Token protocol")
     peek(responseNetwork_in, ResponseMsg) {
       // FIXME, should use a 3rd vnet in some cases
       enqueue(responseNetwork_out, ResponseMsg, latency="1") {
-        out_msg.Address := address;
+        out_msg.Addr := address;
         out_msg.Type := in_msg.Type;
         out_msg.Sender := machineID;
         out_msg.Destination.add(persistentTable.findSmallest(address));
@@ -720,7 +720,7 @@ machine(L2Cache, "Token protocol")
     peek(responseNetwork_in, ResponseMsg) {
       // FIXME, should use a 3rd vnet in some cases
       enqueue(responseNetwork_out, ResponseMsg, latency="1") {
-        out_msg.Address := address;
+        out_msg.Addr := address;
         if (in_msg.Type == CoherenceResponseType:WB_SHARED_DATA) {
           out_msg.Type := CoherenceResponseType:DATA_SHARED;
         } else {
@@ -742,7 +742,7 @@ machine(L2Cache, "Token protocol")
     peek(responseNetwork_in, ResponseMsg) {
       // FIXME, should use a 3rd vnet in some cases
       enqueue(responseNetwork_out, ResponseMsg, latency="1") {
-        out_msg.Address := address;
+        out_msg.Addr := address;
         out_msg.Type := CoherenceResponseType:DATA_OWNER;
         out_msg.Sender := machineID;
         out_msg.Destination.add(persistentTable.findSmallest(address));
@@ -757,20 +757,20 @@ machine(L2Cache, "Token protocol")
 
   action(h_updateFilterFromL1HintOrWB, "h", desc="update filter from received writeback") {
     peek(responseNetwork_in, ResponseMsg) {
-      removeSharer(in_msg.Address, machineIDToNodeID(in_msg.Sender));
+      removeSharer(in_msg.Addr, machineIDToNodeID(in_msg.Sender));
     }
   }
 
   action(j_forwardTransientRequestToLocalSharers, "j", desc="Forward external transient request to local sharers") {
     peek(requestNetwork_in, RequestMsg) {
-      if (filtering_enabled == true && in_msg.RetryNum == 0 && sharersExist(in_msg.Address) == false) {
+      if (filtering_enabled == true && in_msg.RetryNum == 0 && sharersExist(in_msg.Addr) == false) {
         //profile_filter_action(1);
         DPRINTF(RubySlicc, "filtered message, Retry Num: %d\n",
                 in_msg.RetryNum);
       }
       else {
         enqueue(localRequestNetwork_out, RequestMsg, latency=l2_response_latency ) {
-           out_msg.Address := in_msg.Address;
+           out_msg.Addr := in_msg.Addr;
            out_msg.Requestor := in_msg.Requestor;
 
            //
@@ -797,7 +797,7 @@ machine(L2Cache, "Token protocol")
       assert(cache_entry.Tokens > 0);
       //enqueue(responseIntraChipL2Network_out, ResponseMsg, latency="L2_to_L1_RESPONSE_LATENCY") {
       enqueue(responseNetwork_out, ResponseMsg, latency=l2_response_latency) {
-        out_msg.Address := address;
+        out_msg.Addr := address;
         out_msg.Type := CoherenceResponseType:DATA_SHARED;
         out_msg.Sender := machineID;
         out_msg.Destination.add(in_msg.Requestor);
@@ -815,7 +815,7 @@ machine(L2Cache, "Token protocol")
       assert(is_valid(cache_entry));
       assert(cache_entry.Tokens == (max_tokens() / 2) + 1);
       enqueue(responseNetwork_out, ResponseMsg, latency=l2_response_latency) {
-        out_msg.Address := address;
+        out_msg.Addr := address;
         out_msg.Type := CoherenceResponseType:DATA_OWNER;
         out_msg.Sender := machineID;
         out_msg.Destination.add(in_msg.Requestor);
@@ -834,7 +834,7 @@ machine(L2Cache, "Token protocol")
 //      assert(cache_entry.Tokens == max_tokens());
       //enqueue(responseIntraChipL2Network_out, ResponseMsg, latency="L2_to_L1_RESPONSE_LATENCY") {
       enqueue(responseNetwork_out, ResponseMsg, latency=l2_response_latency) {
-        out_msg.Address := address;
+        out_msg.Addr := address;
         out_msg.Type := CoherenceResponseType:DATA_OWNER;
         out_msg.Sender := machineID;
         out_msg.Destination.add(in_msg.Requestor);
@@ -883,9 +883,9 @@ machine(L2Cache, "Token protocol")
     peek(L1requestNetwork_in, RequestMsg) {
       if (machineIDToMachineType(in_msg.Requestor) == MachineType:L1Cache) {
         if (in_msg.Type == CoherenceRequestType:GETX) {
-          setNewWriter(in_msg.Address, machineIDToNodeID(in_msg.Requestor));
+          setNewWriter(in_msg.Addr, machineIDToNodeID(in_msg.Requestor));
         } else if (in_msg.Type == CoherenceRequestType:GETS) {
-          addNewSharer(in_msg.Address, machineIDToNodeID(in_msg.Requestor));
+          addNewSharer(in_msg.Addr, machineIDToNodeID(in_msg.Requestor));
         }
       }
     }
@@ -909,7 +909,7 @@ machine(L2Cache, "Token protocol")
     if (cache_entry.Tokens > 0) {
       peek(requestNetwork_in, RequestMsg) {
         enqueue(responseNetwork_out, ResponseMsg, latency=l2_response_latency) {
-          out_msg.Address := address;
+          out_msg.Addr := address;
           out_msg.Type := CoherenceResponseType:ACK;
           out_msg.Sender := machineID;
           out_msg.Destination.add(in_msg.Requestor);
@@ -927,7 +927,7 @@ machine(L2Cache, "Token protocol")
     if (cache_entry.Tokens > 0) {
       peek(L1requestNetwork_in, RequestMsg) {
         enqueue(responseNetwork_out, ResponseMsg, latency=l2_response_latency) {
-          out_msg.Address := address;
+          out_msg.Addr := address;
           out_msg.Type := CoherenceResponseType:ACK;
           out_msg.Sender := machineID;
           out_msg.Destination.add(in_msg.Requestor);