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, 64 insertions, 64 deletions

diff --git a/src/mem/protocol/MOESI_CMP_token-dir.sm b/src/mem/protocol/MOESI_CMP_token-dir.sm
index 5a5fc7259..854e6e2af 100644
--- a/src/mem/protocol/MOESI_CMP_token-dir.sm
+++ b/src/mem/protocol/MOESI_CMP_token-dir.sm
@@ -252,9 +252,9 @@ machine(Directory, "Token protocol")
     if (memQueue_in.isReady()) {
       peek(memQueue_in, MemoryMsg) {
         if (in_msg.Type == MemoryRequestType:MEMORY_READ) {
-          trigger(Event:Memory_Data, in_msg.Address, TBEs[in_msg.Address]);
+          trigger(Event:Memory_Data, in_msg.Addr, TBEs[in_msg.Addr]);
         } else if (in_msg.Type == MemoryRequestType:MEMORY_WB) {
-          trigger(Event:Memory_Ack, in_msg.Address, TBEs[in_msg.Address]);
+          trigger(Event:Memory_Ack, in_msg.Addr, TBEs[in_msg.Addr]);
         } else {
           DPRINTF(RubySlicc, "%s\n", in_msg.Type);
           error("Invalid message");
@@ -275,32 +275,32 @@ machine(Directory, "Token protocol")
     if (responseNetwork_in.isReady()) {
       peek(responseNetwork_in, ResponseMsg) {
         assert(in_msg.Destination.isElement(machineID));
-        if (getDirectoryEntry(in_msg.Address).Tokens + in_msg.Tokens == max_tokens()) {
+        if (getDirectoryEntry(in_msg.Addr).Tokens + in_msg.Tokens == max_tokens()) {
           if ((in_msg.Type == CoherenceResponseType:DATA_OWNER) ||
               (in_msg.Type == CoherenceResponseType:DATA_SHARED)) {
-            trigger(Event:Data_All_Tokens, in_msg.Address,
-                    TBEs[in_msg.Address]);
+            trigger(Event:Data_All_Tokens, in_msg.Addr,
+                    TBEs[in_msg.Addr]);
           } else if (in_msg.Type == CoherenceResponseType:ACK_OWNER) {
-            trigger(Event:Ack_Owner_All_Tokens, in_msg.Address,
-                    TBEs[in_msg.Address]);
+            trigger(Event:Ack_Owner_All_Tokens, in_msg.Addr,
+                    TBEs[in_msg.Addr]);
           } else if (in_msg.Type == CoherenceResponseType:ACK) {
-            trigger(Event:Ack_All_Tokens, in_msg.Address,
-                    TBEs[in_msg.Address]);
+            trigger(Event:Ack_All_Tokens, in_msg.Addr,
+                    TBEs[in_msg.Addr]);
           } else {
             DPRINTF(RubySlicc, "%s\n", in_msg.Type);
             error("Invalid message");
           }
         } else {
           if (in_msg.Type == CoherenceResponseType:DATA_OWNER) {
-            trigger(Event:Data_Owner, in_msg.Address,
-                    TBEs[in_msg.Address]);
+            trigger(Event:Data_Owner, in_msg.Addr,
+                    TBEs[in_msg.Addr]);
           } else if ((in_msg.Type == CoherenceResponseType:ACK) ||
                      (in_msg.Type == CoherenceResponseType:DATA_SHARED)) {
-            trigger(Event:Tokens, in_msg.Address,
-                    TBEs[in_msg.Address]);
+            trigger(Event:Tokens, in_msg.Addr,
+                    TBEs[in_msg.Addr]);
           } else if (in_msg.Type == CoherenceResponseType:ACK_OWNER) {
-            trigger(Event:Ack_Owner, in_msg.Address,
-                    TBEs[in_msg.Address]);
+            trigger(Event:Ack_Owner, in_msg.Addr,
+                    TBEs[in_msg.Addr]);
           } else {
             DPRINTF(RubySlicc, "%s\n", in_msg.Type);
             error("Invalid message");
@@ -318,52 +318,52 @@ machine(Directory, "Token protocol")
         if (distributed_persistent) {
           // Apply the lockdown or unlockdown message to the table
           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("Invalid message");
           }
 
           // React to the message based on the current state of the table
-          if (persistentTable.isLocked(in_msg.Address)) {
-            if (persistentTable.findSmallest(in_msg.Address) == machineID) {
-              if (getDirectoryEntry(in_msg.Address).Tokens > 0) {
-                trigger(Event:Own_Lock_or_Unlock_Tokens, in_msg.Address,
-                        TBEs[in_msg.Address]);
+          if (persistentTable.isLocked(in_msg.Addr)) {
+            if (persistentTable.findSmallest(in_msg.Addr) == machineID) {
+              if (getDirectoryEntry(in_msg.Addr).Tokens > 0) {
+                trigger(Event:Own_Lock_or_Unlock_Tokens, in_msg.Addr,
+                        TBEs[in_msg.Addr]);
               } else {
-                trigger(Event:Own_Lock_or_Unlock, in_msg.Address,
-                        TBEs[in_msg.Address]);
+                trigger(Event:Own_Lock_or_Unlock, in_msg.Addr,
+                        TBEs[in_msg.Addr]);
               }
             } else {
               // locked
-              trigger(Event:Lockdown, in_msg.Address, TBEs[in_msg.Address]);
+              trigger(Event:Lockdown, in_msg.Addr, TBEs[in_msg.Addr]);
             }
           } else {
             // unlocked
-            trigger(Event:Unlockdown, in_msg.Address, TBEs[in_msg.Address]);
+            trigger(Event:Unlockdown, in_msg.Addr, TBEs[in_msg.Addr]);
           }
         }
         else {
-          if (persistentTable.findSmallest(in_msg.Address) == machineID) {
-              if (getDirectoryEntry(in_msg.Address).Tokens > 0) {
-                trigger(Event:Own_Lock_or_Unlock_Tokens, in_msg.Address,
-                        TBEs[in_msg.Address]);
+          if (persistentTable.findSmallest(in_msg.Addr) == machineID) {
+              if (getDirectoryEntry(in_msg.Addr).Tokens > 0) {
+                trigger(Event:Own_Lock_or_Unlock_Tokens, in_msg.Addr,
+                        TBEs[in_msg.Addr]);
               } else {
-                trigger(Event:Own_Lock_or_Unlock, in_msg.Address,
-                        TBEs[in_msg.Address]);
+                trigger(Event:Own_Lock_or_Unlock, in_msg.Addr,
+                        TBEs[in_msg.Addr]);
               }
           } else if (in_msg.Type == PersistentRequestType:GETX_PERSISTENT) {
             // locked
-            trigger(Event:Lockdown, in_msg.Address, TBEs[in_msg.Address]);
+            trigger(Event:Lockdown, in_msg.Addr, TBEs[in_msg.Addr]);
           } else if (in_msg.Type == PersistentRequestType:GETS_PERSISTENT) {
             // locked
-            trigger(Event:Lockdown, in_msg.Address, TBEs[in_msg.Address]);
+            trigger(Event:Lockdown, in_msg.Addr, TBEs[in_msg.Addr]);
           } else if (in_msg.Type == PersistentRequestType:DEACTIVATE_PERSISTENT) {
             // unlocked
-            trigger(Event:Unlockdown, in_msg.Address, TBEs[in_msg.Address]);
+            trigger(Event:Unlockdown, in_msg.Addr, TBEs[in_msg.Addr]);
           } else {
             error("Invalid message");
           }
@@ -377,9 +377,9 @@ machine(Directory, "Token protocol")
       peek(requestNetwork_in, RequestMsg) {
         assert(in_msg.Destination.isElement(machineID));
         if (in_msg.Type == CoherenceRequestType:GETS) {
-          trigger(Event:GETS, in_msg.Address, TBEs[in_msg.Address]);
+          trigger(Event:GETS, in_msg.Addr, TBEs[in_msg.Addr]);
         } else if (in_msg.Type == CoherenceRequestType:GETX) {
-          trigger(Event:GETX, in_msg.Address, TBEs[in_msg.Address]);
+          trigger(Event:GETX, in_msg.Addr, TBEs[in_msg.Addr]);
         } else {
           error("Invalid message");
         }
@@ -415,11 +415,11 @@ machine(Directory, "Token protocol")
       peek(requestNetwork_in, RequestMsg) {
         // enqueue(responseNetwork_out, ResponseMsg, latency="DIRECTORY_CACHE_LATENCY") {// FIXME?
         enqueue(responseNetwork_out, ResponseMsg, latency=directory_latency) {// FIXME?
-          out_msg.Address := address;
+          out_msg.Addr := address;
           out_msg.Type := CoherenceResponseType:ACK;
           out_msg.Sender := machineID;
           out_msg.Destination.add(in_msg.Requestor);
-          out_msg.Tokens := getDirectoryEntry(in_msg.Address).Tokens;
+          out_msg.Tokens := getDirectoryEntry(in_msg.Addr).Tokens;
           out_msg.MessageSize := MessageSizeType:Response_Control;
         }
       }
@@ -430,7 +430,7 @@ machine(Directory, "Token protocol")
   action(px_tryIssuingPersistentGETXRequest, "px", desc="...") {
     if (okToIssueStarving(address, machineID) && (starving == false)) {
       enqueue(persistentNetwork_out, PersistentMsg, latency = "1") {
-        out_msg.Address := address;
+        out_msg.Addr := address;
         out_msg.Type := PersistentRequestType:GETX_PERSISTENT;
         out_msg.Requestor := machineID;
         out_msg.Destination.broadcast(MachineType:L1Cache);
@@ -476,7 +476,7 @@ machine(Directory, "Token protocol")
       //
       assert(getDirectoryEntry(address).Tokens != max_tokens());
       enqueue(requestNetwork_out, RequestMsg, latency = "1") {
-        out_msg.Address := address;
+        out_msg.Addr := address;
         out_msg.Type := CoherenceRequestType:GETX;
         out_msg.Requestor := machineID;
 
@@ -500,7 +500,7 @@ machine(Directory, "Token protocol")
   action(ps_tryIssuingPersistentGETSRequest, "ps", desc="...") {
     if (okToIssueStarving(address, machineID) && (starving == false)) {
       enqueue(persistentNetwork_out, PersistentMsg, latency = "1") {
-        out_msg.Address := address;
+        out_msg.Addr := address;
         out_msg.Type := PersistentRequestType:GETS_PERSISTENT;
         out_msg.Requestor := machineID;
         out_msg.Destination.broadcast(MachineType:L1Cache);
@@ -542,7 +542,7 @@ machine(Directory, "Token protocol")
   action(br_broadcastRead, "br", desc="Broadcast GETS for data") {
     peek(dmaRequestQueue_in, DMARequestMsg) {
       enqueue(requestNetwork_out, RequestMsg, latency = "1") {
-        out_msg.Address := address;
+        out_msg.Addr := address;
         out_msg.Type := CoherenceRequestType:GETS;
         out_msg.Requestor := machineID;
 
@@ -568,7 +568,7 @@ machine(Directory, "Token protocol")
     if (getDirectoryEntry(address).Tokens > 0) {
       // enqueue(responseNetwork_out, ResponseMsg, latency="DIRECTORY_CACHE_LATENCY") {// FIXME?
       enqueue(responseNetwork_out, ResponseMsg, latency=directory_latency) {// FIXME?
-        out_msg.Address := address;
+        out_msg.Addr := address;
         out_msg.Type := CoherenceResponseType:ACK;
         out_msg.Sender := machineID;
         out_msg.Destination.add(persistentTable.findSmallest(address));
@@ -582,13 +582,13 @@ machine(Directory, "Token protocol")
   action(d_sendMemoryDataWithAllTokens, "d", desc="Send data and tokens to requestor") {
     peek(memQueue_in, MemoryMsg) {
       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(in_msg.OriginalRequestorMachId);
         assert(getDirectoryEntry(address).Tokens > 0);
-        out_msg.Tokens := getDirectoryEntry(in_msg.Address).Tokens;
-        out_msg.DataBlk := getDirectoryEntry(in_msg.Address).DataBlk;
+        out_msg.Tokens := getDirectoryEntry(in_msg.Addr).Tokens;
+        out_msg.DataBlk := getDirectoryEntry(in_msg.Addr).DataBlk;
         out_msg.Dirty := false;
         out_msg.MessageSize := MessageSizeType:Response_Data;
       }
@@ -599,7 +599,7 @@ machine(Directory, "Token protocol")
   action(dd_sendMemDataToStarver, "\d", desc="Send data and tokens to starver") {
     peek(memQueue_in, MemoryMsg) {
       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));
@@ -615,7 +615,7 @@ machine(Directory, "Token protocol")
 
   action(de_sendTbeDataToStarver, "de", desc="Send data and tokens to starver") {
     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));
@@ -631,7 +631,7 @@ machine(Directory, "Token protocol")
   action(qf_queueMemoryFetchRequest, "qf", desc="Queue off-chip fetch request") {
     peek(requestNetwork_in, RequestMsg) {
       enqueue(memQueue_out, MemoryMsg, latency="1") {
-        out_msg.Address := address;
+        out_msg.Addr := address;
         out_msg.Type := MemoryRequestType:MEMORY_READ;
         out_msg.Sender := machineID;
         out_msg.OriginalRequestorMachId := in_msg.Requestor;
@@ -644,7 +644,7 @@ machine(Directory, "Token protocol")
 
   action(qp_queueMemoryForPersistent, "qp", desc="Queue off-chip fetch request") {
     enqueue(memQueue_out, MemoryMsg, latency="1") {
-      out_msg.Address := address;
+      out_msg.Addr := address;
       out_msg.Type := MemoryRequestType:MEMORY_READ;
       out_msg.Sender := machineID;
       out_msg.OriginalRequestorMachId := persistentTable.findSmallest(address);
@@ -657,7 +657,7 @@ machine(Directory, "Token protocol")
   action(fd_memoryDma, "fd", desc="Queue off-chip fetch request") {
     peek(dmaRequestQueue_in, DMARequestMsg) {
       enqueue(memQueue_out, MemoryMsg, latency="1") {
-        out_msg.Address := address;
+        out_msg.Addr := address;
         out_msg.Type := MemoryRequestType:MEMORY_READ;
         out_msg.Sender := machineID;
         out_msg.OriginalRequestorMachId := in_msg.Requestor;
@@ -670,7 +670,7 @@ machine(Directory, "Token protocol")
 
   action(lq_queueMemoryWbRequest, "lq", desc="Write data to memory") {
     enqueue(memQueue_out, MemoryMsg, latency="1") {
-      out_msg.Address := address;
+      out_msg.Addr := address;
       out_msg.Type := MemoryRequestType:MEMORY_WB;
       out_msg.DataBlk := getDirectoryEntry(address).DataBlk;
       DPRINTF(RubySlicc, "%s\n", out_msg);
@@ -679,7 +679,7 @@ machine(Directory, "Token protocol")
 
   action(ld_queueMemoryDmaWriteFromTbe, "ld", desc="Write DMA data to memory") {
     enqueue(memQueue_out, MemoryMsg, latency="1") {
-      out_msg.Address := address;
+      out_msg.Addr := address;
       out_msg.Type := MemoryRequestType:MEMORY_WB;
       // first, initialize the data blk to the current version of system memory
       out_msg.DataBlk := tbe.DataBlk;
@@ -691,7 +691,7 @@ machine(Directory, "Token protocol")
 
   action(lr_queueMemoryDmaReadWriteback, "lr", desc="Write DMA data from read to memory") {
     enqueue(memQueue_out, MemoryMsg, latency="1") {
-      out_msg.Address := address;
+      out_msg.Addr := address;
       out_msg.Type := MemoryRequestType:MEMORY_WB;
       // first, initialize the data blk to the current version of system memory
       out_msg.DataBlk := tbe.DataBlk;
@@ -717,7 +717,7 @@ machine(Directory, "Token protocol")
       assert(starving == true);
 
       enqueue(persistentNetwork_out, PersistentMsg, latency = "1") {
-        out_msg.Address := address;
+        out_msg.Addr := address;
         out_msg.Type := PersistentRequestType:DEACTIVATE_PERSISTENT;
         out_msg.Requestor := machineID;
         out_msg.Destination.broadcast(MachineType:L1Cache);
@@ -804,22 +804,22 @@ machine(Directory, "Token protocol")
 
   action(m_writeDataToMemory, "m", desc="Write dirty writeback to memory") {
     peek(responseNetwork_in, ResponseMsg) {
-      getDirectoryEntry(in_msg.Address).DataBlk := in_msg.DataBlk;
+      getDirectoryEntry(in_msg.Addr).DataBlk := in_msg.DataBlk;
       DPRINTF(RubySlicc, "Address: %s, Data Block: %s\n",
-              in_msg.Address, in_msg.DataBlk);
+              in_msg.Addr, in_msg.DataBlk);
     }
   }
 
   action(n_checkData, "n", desc="Check incoming clean data message") {
     peek(responseNetwork_in, ResponseMsg) {
-      assert(getDirectoryEntry(in_msg.Address).DataBlk == in_msg.DataBlk);
+      assert(getDirectoryEntry(in_msg.Addr).DataBlk == in_msg.DataBlk);
     }
   }
 
   action(r_bounceResponse, "r", desc="Bounce response to starving processor") {
     peek(responseNetwork_in, ResponseMsg) {
       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));
@@ -864,18 +864,18 @@ machine(Directory, "Token protocol")
       // implementation.  We include the data in the "dataless"
       // message so we can assert the clean data matches the datablock
       // in memory
-      assert(getDirectoryEntry(in_msg.Address).DataBlk == in_msg.DataBlk);
+      assert(getDirectoryEntry(in_msg.Addr).DataBlk == in_msg.DataBlk);
 
       // Bounce the message, but "re-associate" the data and the owner
       // token.  In essence we're converting an ACK_OWNER message to a
       // DATA_OWNER message, keeping the number of tokens the same.
       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));
         out_msg.Tokens := in_msg.Tokens;
-        out_msg.DataBlk := getDirectoryEntry(in_msg.Address).DataBlk;
+        out_msg.DataBlk := getDirectoryEntry(in_msg.Addr).DataBlk;
         out_msg.Dirty := in_msg.Dirty;
         out_msg.MessageSize := MessageSizeType:Response_Data;
       }