ruby: rename variables Addr to addr

Avoid clash between type Addr and variable name Addr.

1 files changed, 106 insertions, 106 deletions

diff --git a/src/mem/protocol/MOESI_CMP_directory-L2cache.sm b/src/mem/protocol/MOESI_CMP_directory-L2cache.sm
index 714f52f32..36278b8f0 100644
--- a/src/mem/protocol/MOESI_CMP_directory-L2cache.sm
+++ b/src/mem/protocol/MOESI_CMP_directory-L2cache.sm
@@ -192,7 +192,7 @@ machine(L2Cache, "Token protocol")
 
   // TBE fields
   structure(TBE, desc="...") {
-    Address Addr,                      desc="Physical address for this TBE";
+    Address addr,                      desc="Physical address for this TBE";
     State TBEState,                       desc="Transient state";
     Address PC,                           desc="Program counter of request";
     DataBlock DataBlk,                    desc="Buffer for the data block";
@@ -581,8 +581,8 @@ machine(L2Cache, "Token protocol")
     if (triggerQueue_in.isReady()) {
       peek(triggerQueue_in, TriggerMsg) {
         if (in_msg.Type == TriggerType:ALL_ACKS) {
-          trigger(Event:All_Acks, in_msg.Addr,
-                  getCacheEntry(in_msg.Addr), TBEs[in_msg.Addr]);
+          trigger(Event:All_Acks, in_msg.addr,
+                  getCacheEntry(in_msg.addr), TBEs[in_msg.addr]);
         } else {
           error("Unexpected message");
         }
@@ -597,27 +597,27 @@ machine(L2Cache, "Token protocol")
       peek(requestNetwork_in, RequestMsg) {
         if (in_msg.Type == CoherenceRequestType:GETX || in_msg.Type == CoherenceRequestType:DMA_WRITE) {
           if (in_msg.Requestor == machineID) {
-            trigger(Event:Own_GETX, in_msg.Addr,
-                    getCacheEntry(in_msg.Addr), TBEs[in_msg.Addr]);
+            trigger(Event:Own_GETX, in_msg.addr,
+                    getCacheEntry(in_msg.addr), TBEs[in_msg.addr]);
           } else {
-            trigger(Event:Fwd_GETX, in_msg.Addr,
-                    getCacheEntry(in_msg.Addr), TBEs[in_msg.Addr]);
+            trigger(Event:Fwd_GETX, in_msg.addr,
+                    getCacheEntry(in_msg.addr), TBEs[in_msg.addr]);
           }
         } else if (in_msg.Type == CoherenceRequestType:GETS) {
-          trigger(Event:Fwd_GETS, in_msg.Addr,
-                  getCacheEntry(in_msg.Addr), TBEs[in_msg.Addr]);
+          trigger(Event:Fwd_GETS, in_msg.addr,
+                  getCacheEntry(in_msg.addr), TBEs[in_msg.addr]);
         } else if(in_msg.Type == CoherenceRequestType:DMA_READ) {
-          trigger(Event:Fwd_DMA, in_msg.Addr,
-                  getCacheEntry(in_msg.Addr), TBEs[in_msg.Addr]);
+          trigger(Event:Fwd_DMA, in_msg.addr,
+                  getCacheEntry(in_msg.addr), TBEs[in_msg.addr]);
         } else if (in_msg.Type == CoherenceRequestType:INV) {
-          trigger(Event:Inv, in_msg.Addr,
-                  getCacheEntry(in_msg.Addr), TBEs[in_msg.Addr]);
+          trigger(Event:Inv, in_msg.addr,
+                  getCacheEntry(in_msg.addr), TBEs[in_msg.addr]);
         } else if (in_msg.Type == CoherenceRequestType:WB_ACK) {
-          trigger(Event:Writeback_Ack, in_msg.Addr,
-                  getCacheEntry(in_msg.Addr), TBEs[in_msg.Addr]);
+          trigger(Event:Writeback_Ack, in_msg.addr,
+                  getCacheEntry(in_msg.addr), TBEs[in_msg.addr]);
         } else if (in_msg.Type == CoherenceRequestType:WB_NACK) {
-          trigger(Event:Writeback_Nack, in_msg.Addr,
-                  getCacheEntry(in_msg.Addr), TBEs[in_msg.Addr]);
+          trigger(Event:Writeback_Nack, in_msg.addr,
+                  getCacheEntry(in_msg.addr), TBEs[in_msg.addr]);
         } else {
           error("Unexpected message");
         }
@@ -630,26 +630,26 @@ machine(L2Cache, "Token protocol")
       peek(L1requestNetwork_in, RequestMsg) {
         assert(in_msg.Destination.isElement(machineID));
         if (in_msg.Type == CoherenceRequestType:GETX) {
-          trigger(Event:L1_GETX, in_msg.Addr,
-                  getCacheEntry(in_msg.Addr), TBEs[in_msg.Addr]);
+          trigger(Event:L1_GETX, in_msg.addr,
+                  getCacheEntry(in_msg.addr), TBEs[in_msg.addr]);
         } else if (in_msg.Type == CoherenceRequestType:GETS) {
-            trigger(Event:L1_GETS, in_msg.Addr,
-                  getCacheEntry(in_msg.Addr), TBEs[in_msg.Addr]);
+            trigger(Event:L1_GETS, in_msg.addr,
+                  getCacheEntry(in_msg.addr), TBEs[in_msg.addr]);
         } else if (in_msg.Type == CoherenceRequestType:PUTO) {
-          trigger(Event:L1_PUTO, in_msg.Addr,
-                  getCacheEntry(in_msg.Addr), TBEs[in_msg.Addr]);
+          trigger(Event:L1_PUTO, in_msg.addr,
+                  getCacheEntry(in_msg.addr), TBEs[in_msg.addr]);
         } else if (in_msg.Type == CoherenceRequestType:PUTX) {
-          trigger(Event:L1_PUTX, in_msg.Addr,
-                  getCacheEntry(in_msg.Addr), TBEs[in_msg.Addr]);
+          trigger(Event:L1_PUTX, in_msg.addr,
+                  getCacheEntry(in_msg.addr), TBEs[in_msg.addr]);
         } else if (in_msg.Type == CoherenceRequestType:PUTS) {
-          Entry cache_entry := getCacheEntry(in_msg.Addr);
-          if (isOnlySharer(cache_entry, in_msg.Addr, in_msg.Requestor)) {
-            trigger(Event:L1_PUTS_only, in_msg.Addr,
-                    cache_entry, TBEs[in_msg.Addr]);
+          Entry cache_entry := getCacheEntry(in_msg.addr);
+          if (isOnlySharer(cache_entry, in_msg.addr, in_msg.Requestor)) {
+            trigger(Event:L1_PUTS_only, in_msg.addr,
+                    cache_entry, TBEs[in_msg.addr]);
           }
           else {
-            trigger(Event:L1_PUTS, in_msg.Addr,
-                    cache_entry, TBEs[in_msg.Addr]);
+            trigger(Event:L1_PUTS, in_msg.addr,
+                    cache_entry, TBEs[in_msg.addr]);
           }
         } else {
           error("Unexpected message");
@@ -666,52 +666,52 @@ machine(L2Cache, "Token protocol")
         assert(in_msg.Destination.isElement(machineID));
         if (in_msg.Type == CoherenceResponseType:ACK) {
           if (in_msg.SenderMachine == MachineType:L2Cache) {
-            trigger(Event:ExtAck, in_msg.Addr,
-                    getCacheEntry(in_msg.Addr), TBEs[in_msg.Addr]);
+            trigger(Event:ExtAck, in_msg.addr,
+                    getCacheEntry(in_msg.addr), TBEs[in_msg.addr]);
           }
           else {
-            trigger(Event:IntAck, in_msg.Addr,
-                    getCacheEntry(in_msg.Addr), TBEs[in_msg.Addr]);
+            trigger(Event:IntAck, in_msg.addr,
+                    getCacheEntry(in_msg.addr), TBEs[in_msg.addr]);
           }
         } else if (in_msg.Type == CoherenceResponseType:DATA) {
-          trigger(Event:Data, in_msg.Addr,
-                  getCacheEntry(in_msg.Addr), TBEs[in_msg.Addr]);
+          trigger(Event:Data, in_msg.addr,
+                  getCacheEntry(in_msg.addr), TBEs[in_msg.addr]);
         } else if (in_msg.Type == CoherenceResponseType:DATA_EXCLUSIVE) {
-          trigger(Event:Data_Exclusive, in_msg.Addr,
-                  getCacheEntry(in_msg.Addr), TBEs[in_msg.Addr]);
+          trigger(Event:Data_Exclusive, in_msg.addr,
+                  getCacheEntry(in_msg.addr), TBEs[in_msg.addr]);
         } else if (in_msg.Type == CoherenceResponseType:UNBLOCK) {
-          trigger(Event:Unblock, in_msg.Addr,
-                  getCacheEntry(in_msg.Addr), TBEs[in_msg.Addr]);
+          trigger(Event:Unblock, in_msg.addr,
+                  getCacheEntry(in_msg.addr), TBEs[in_msg.addr]);
         } else if (in_msg.Type == CoherenceResponseType:UNBLOCK_EXCLUSIVE) {
-          trigger(Event:Exclusive_Unblock, in_msg.Addr,
-                  getCacheEntry(in_msg.Addr), TBEs[in_msg.Addr]);
+          trigger(Event:Exclusive_Unblock, in_msg.addr,
+                  getCacheEntry(in_msg.addr), TBEs[in_msg.addr]);
         } else if (in_msg.Type == CoherenceResponseType:WRITEBACK_DIRTY_DATA) {
-          Entry cache_entry := getCacheEntry(in_msg.Addr);
+          Entry cache_entry := getCacheEntry(in_msg.addr);
           if (is_invalid(cache_entry) &&
-                   L2cache.cacheAvail(in_msg.Addr) == false) {
-            trigger(Event:L2_Replacement, L2cache.cacheProbe(in_msg.Addr),
-                    getCacheEntry(L2cache.cacheProbe(in_msg.Addr)),
-                    TBEs[L2cache.cacheProbe(in_msg.Addr)]);
+                   L2cache.cacheAvail(in_msg.addr) == false) {
+            trigger(Event:L2_Replacement, L2cache.cacheProbe(in_msg.addr),
+                    getCacheEntry(L2cache.cacheProbe(in_msg.addr)),
+                    TBEs[L2cache.cacheProbe(in_msg.addr)]);
           }
           else {
-            trigger(Event:L1_WBDIRTYDATA, in_msg.Addr,
-                    cache_entry, TBEs[in_msg.Addr]);
+            trigger(Event:L1_WBDIRTYDATA, in_msg.addr,
+                    cache_entry, TBEs[in_msg.addr]);
           }
         } else if (in_msg.Type == CoherenceResponseType:WRITEBACK_CLEAN_DATA) {
-          Entry cache_entry := getCacheEntry(in_msg.Addr);
+          Entry cache_entry := getCacheEntry(in_msg.addr);
           if (is_invalid(cache_entry) &&
-                   L2cache.cacheAvail(in_msg.Addr) == false) {
-            trigger(Event:L2_Replacement, L2cache.cacheProbe(in_msg.Addr),
-                    getCacheEntry(L2cache.cacheProbe(in_msg.Addr)),
-                    TBEs[L2cache.cacheProbe(in_msg.Addr)]);
+                   L2cache.cacheAvail(in_msg.addr) == false) {
+            trigger(Event:L2_Replacement, L2cache.cacheProbe(in_msg.addr),
+                    getCacheEntry(L2cache.cacheProbe(in_msg.addr)),
+                    TBEs[L2cache.cacheProbe(in_msg.addr)]);
           }
           else {
-            trigger(Event:L1_WBCLEANDATA, in_msg.Addr,
-                    cache_entry, TBEs[in_msg.Addr]);
+            trigger(Event:L1_WBCLEANDATA, in_msg.addr,
+                    cache_entry, TBEs[in_msg.addr]);
           }
         } else if (in_msg.Type == CoherenceResponseType:DMA_ACK) {
-          trigger(Event:DmaAck, in_msg.Addr,
-                  getCacheEntry(in_msg.Addr), TBEs[in_msg.Addr]);
+          trigger(Event:DmaAck, in_msg.addr,
+                  getCacheEntry(in_msg.addr), TBEs[in_msg.addr]);
         } else {
           error("Unexpected message");
         }
@@ -725,7 +725,7 @@ machine(L2Cache, "Token protocol")
   action(a_issueGETS, "a", desc="issue local request globally") {
     peek(L1requestNetwork_in, RequestMsg) {
       enqueue(globalRequestNetwork_out, RequestMsg, request_latency) {
-        out_msg.Addr := address;
+        out_msg.addr := address;
         out_msg.Type := CoherenceRequestType:GETS;
         out_msg.RequestorMachine := MachineType:L2Cache;
         out_msg.Requestor := machineID;
@@ -738,7 +738,7 @@ machine(L2Cache, "Token protocol")
   action(a_issueGETX, "\a", desc="issue local request globally") {
     peek(L1requestNetwork_in, RequestMsg) {
       enqueue(globalRequestNetwork_out, RequestMsg, request_latency) {
-        out_msg.Addr := address;
+        out_msg.addr := address;
         out_msg.Type := CoherenceRequestType:GETX;
         out_msg.RequestorMachine := MachineType:L2Cache;
         out_msg.Requestor := machineID;
@@ -750,7 +750,7 @@ machine(L2Cache, "Token protocol")
 
   action(b_issuePUTX, "b", desc="Issue PUTX") {
     enqueue(globalRequestNetwork_out, RequestMsg, request_latency) {
-      out_msg.Addr := address;
+      out_msg.addr := address;
       out_msg.Type := CoherenceRequestType:PUTX;
       out_msg.RequestorMachine := MachineType:L2Cache;
       out_msg.Requestor := machineID;
@@ -761,7 +761,7 @@ machine(L2Cache, "Token protocol")
 
   action(b_issuePUTO, "\b", desc="Issue PUTO") {
     enqueue(globalRequestNetwork_out, RequestMsg, request_latency) {
-      out_msg.Addr := address;
+      out_msg.addr := address;
       out_msg.Type := CoherenceRequestType:PUTO;
       out_msg.Requestor := machineID;
       out_msg.RequestorMachine := MachineType:L2Cache;
@@ -773,7 +773,7 @@ machine(L2Cache, "Token protocol")
   /* PUTO, but local sharers exist */
   action(b_issuePUTO_ls, "\bb", desc="Issue PUTO") {
     enqueue(globalRequestNetwork_out, RequestMsg, request_latency) {
-      out_msg.Addr := address;
+      out_msg.addr := address;
       out_msg.Type := CoherenceRequestType:PUTO_SHARERS;
       out_msg.Requestor := machineID;
       out_msg.RequestorMachine := MachineType:L2Cache;
@@ -785,7 +785,7 @@ machine(L2Cache, "Token protocol")
   action(c_sendDataFromTBEToL1GETS, "c", desc="Send data from TBE to L1 requestors in TBE") {
     assert(is_valid(tbe));
     enqueue(responseNetwork_out, ResponseMsg, response_latency) {
-      out_msg.Addr := address;
+      out_msg.addr := address;
       out_msg.Type := CoherenceResponseType:DATA;
       out_msg.Sender := machineID;
       out_msg.SenderMachine := MachineType:L2Cache;
@@ -803,7 +803,7 @@ machine(L2Cache, "Token protocol")
   action(c_sendDataFromTBEToL1GETX, "\c", desc="Send data from TBE to L1 requestors in TBE") {
     assert(is_valid(tbe));
     enqueue(responseNetwork_out, ResponseMsg, response_latency) {
-      out_msg.Addr := address;
+      out_msg.addr := address;
       out_msg.Type := CoherenceResponseType:DATA_EXCLUSIVE;
       out_msg.Sender := machineID;
       out_msg.SenderMachine := MachineType:L2Cache;
@@ -820,7 +820,7 @@ machine(L2Cache, "Token protocol")
   action(c_sendExclusiveDataFromTBEToL1GETS, "\cc", desc="Send data from TBE to L1 requestors in TBE") {
     assert(is_valid(tbe));
     enqueue(responseNetwork_out, ResponseMsg, response_latency) {
-      out_msg.Addr := address;
+      out_msg.addr := address;
       out_msg.Type := CoherenceResponseType:DATA_EXCLUSIVE;
       out_msg.Sender := machineID;
       out_msg.SenderMachine := MachineType:L2Cache;
@@ -834,7 +834,7 @@ machine(L2Cache, "Token protocol")
   action(c_sendDataFromTBEToFwdGETX, "cc", desc="Send data from TBE to external GETX") {
     assert(is_valid(tbe));
     enqueue(responseNetwork_out, ResponseMsg, response_latency) {
-      out_msg.Addr := address;
+      out_msg.addr := address;
       out_msg.Type := CoherenceResponseType:DATA_EXCLUSIVE;
       out_msg.Sender := machineID;
       out_msg.SenderMachine := MachineType:L2Cache;
@@ -850,7 +850,7 @@ machine(L2Cache, "Token protocol")
     assert(is_valid(tbe));
     peek(requestNetwork_in, RequestMsg) {
       enqueue(responseNetwork_out, ResponseMsg, response_latency) {
-        out_msg.Addr := address;
+        out_msg.addr := address;
         out_msg.Type := CoherenceResponseType:DATA;
         out_msg.Sender := machineID;
         out_msg.SenderMachine := MachineType:L2Cache;
@@ -870,7 +870,7 @@ machine(L2Cache, "Token protocol")
   action(c_sendDataFromTBEToFwdGETS, "ccc", desc="Send data from TBE to external GETX") {
     assert(is_valid(tbe));
     enqueue(responseNetwork_out, ResponseMsg, response_latency) {
-      out_msg.Addr := address;
+      out_msg.addr := address;
       out_msg.Type := CoherenceResponseType:DATA;
       out_msg.Sender := machineID;
       out_msg.SenderMachine := MachineType:L2Cache;
@@ -889,7 +889,7 @@ machine(L2Cache, "Token protocol")
   action(c_sendExclusiveDataFromTBEToFwdGETS, "\ccc", desc="Send data from TBE to external GETX") {
     assert(is_valid(tbe));
     enqueue(responseNetwork_out, ResponseMsg, response_latency) {
-      out_msg.Addr := address;
+      out_msg.addr := address;
       out_msg.Type := CoherenceResponseType:DATA_EXCLUSIVE;
       out_msg.Sender := machineID;
       out_msg.SenderMachine := MachineType:L2Cache;
@@ -907,7 +907,7 @@ machine(L2Cache, "Token protocol")
     assert(is_valid(cache_entry));
     peek(L1requestNetwork_in, RequestMsg) {
       enqueue(responseNetwork_out, ResponseMsg, response_latency) {
-        out_msg.Addr := address;
+        out_msg.addr := address;
         out_msg.Type := CoherenceResponseType:DATA;
         out_msg.Sender := machineID;
         out_msg.SenderMachine := MachineType:L2Cache;
@@ -928,7 +928,7 @@ machine(L2Cache, "Token protocol")
     peek(L1requestNetwork_in, RequestMsg) {
       enqueue(responseNetwork_out, ResponseMsg, response_latency) {
         assert(is_valid(tbe));
-        out_msg.Addr := address;
+        out_msg.addr := address;
         out_msg.Type := CoherenceResponseType:DATA_EXCLUSIVE;
         out_msg.Sender := machineID;
         out_msg.SenderMachine := MachineType:L2Cache;
@@ -947,7 +947,7 @@ machine(L2Cache, "Token protocol")
     assert(is_valid(cache_entry));
     peek(requestNetwork_in, RequestMsg) {
       enqueue(responseNetwork_out, ResponseMsg, response_latency) {
-        out_msg.Addr := address;
+        out_msg.addr := address;
         out_msg.Type := CoherenceResponseType:DATA_EXCLUSIVE;
         out_msg.Sender := machineID;
         out_msg.SenderMachine := MachineType:L2Cache;
@@ -967,7 +967,7 @@ machine(L2Cache, "Token protocol")
     assert(is_valid(cache_entry));
     peek(requestNetwork_in, RequestMsg) {
       enqueue(responseNetwork_out, ResponseMsg, response_latency) {
-        out_msg.Addr := address;
+        out_msg.addr := address;
         out_msg.Type := CoherenceResponseType:DATA;
         out_msg.Sender := machineID;
         out_msg.SenderMachine := MachineType:L2Cache;
@@ -987,7 +987,7 @@ machine(L2Cache, "Token protocol")
     assert(is_valid(cache_entry));
     peek(requestNetwork_in, RequestMsg) {
       enqueue(responseNetwork_out, ResponseMsg, response_latency) {
-        out_msg.Addr := address;
+        out_msg.addr := address;
         out_msg.Type := CoherenceResponseType:DATA_EXCLUSIVE;
         out_msg.Sender := machineID;
         out_msg.SenderMachine := MachineType:L2Cache;
@@ -1002,7 +1002,7 @@ machine(L2Cache, "Token protocol")
   action(e_sendAck, "e", desc="Send ack with the tokens we've collected thus far.") {
     enqueue(responseNetwork_out, ResponseMsg, response_latency) {
       assert(is_valid(tbe));
-      out_msg.Addr := address;
+      out_msg.addr := address;
       out_msg.Type := CoherenceResponseType:ACK;
       out_msg.Sender := machineID;
       out_msg.SenderMachine := MachineType:L2Cache;
@@ -1016,7 +1016,7 @@ machine(L2Cache, "Token protocol")
   action(e_sendAckToL1Requestor, "\e", desc="Send ack with the tokens we've collected thus far.") {
     peek(L1requestNetwork_in, RequestMsg) {
       enqueue(responseNetwork_out, ResponseMsg, response_latency) {
-        out_msg.Addr := address;
+        out_msg.addr := address;
         out_msg.Type := CoherenceResponseType:ACK;
         out_msg.Sender := machineID;
         out_msg.SenderMachine := MachineType:L2Cache;
@@ -1030,7 +1030,7 @@ machine(L2Cache, "Token protocol")
   action(e_sendAckToL1RequestorFromTBE, "eee", desc="Send ack with the tokens we've collected thus far.") {
     enqueue(responseNetwork_out, ResponseMsg, response_latency) {
       assert(is_valid(tbe));
-      out_msg.Addr := address;
+      out_msg.addr := address;
       out_msg.Type := CoherenceResponseType:ACK;
       out_msg.Sender := machineID;
       out_msg.SenderMachine := MachineType:L2Cache;
@@ -1052,7 +1052,7 @@ machine(L2Cache, "Token protocol")
     }
 
     enqueue( localRequestNetwork_out, RequestMsg, response_latency ) {
-      out_msg.Addr := address;
+      out_msg.addr := address;
       out_msg.Type := CoherenceRequestType:INV;
       out_msg.Requestor := machineID;
       out_msg.RequestorMachine := MachineType:L2Cache;
@@ -1073,7 +1073,7 @@ machine(L2Cache, "Token protocol")
 
     if (countLocalSharers(cache_entry, address) > 0) {
       enqueue( localRequestNetwork_out, RequestMsg, response_latency ) {
-        out_msg.Addr := address;
+        out_msg.addr := address;
         out_msg.Type := CoherenceRequestType:INV;
         out_msg.Requestor := machineID;
         out_msg.RequestorMachine := MachineType:L2Cache;
@@ -1105,7 +1105,7 @@ machine(L2Cache, "Token protocol")
           }
 
           enqueue( localRequestNetwork_out, RequestMsg, response_latency ) {
-            out_msg.Addr := address;
+            out_msg.addr := address;
             out_msg.Type := CoherenceRequestType:INV;
             out_msg.Requestor := in_msg.Requestor;
             out_msg.RequestorMachine := MachineType:L1Cache;
@@ -1131,7 +1131,7 @@ machine(L2Cache, "Token protocol")
       }
     }
     enqueue( localRequestNetwork_out, RequestMsg, response_latency ) {
-        out_msg.Addr := address;
+        out_msg.addr := address;
         out_msg.Type := CoherenceRequestType:INV;
         out_msg.Requestor := tbe.L1_GetX_ID;
         out_msg.RequestorMachine := MachineType:L1Cache;
@@ -1144,7 +1144,7 @@ machine(L2Cache, "Token protocol")
 
   action(f_sendUnblock, "f", desc="Send unblock to global directory") {
     enqueue(responseNetwork_out, ResponseMsg, response_latency) {
-      out_msg.Addr := address;
+      out_msg.addr := address;
       out_msg.Type := CoherenceResponseType:UNBLOCK;
       out_msg.Destination.add(map_Address_to_Directory(address));
       out_msg.Sender := machineID;
@@ -1156,7 +1156,7 @@ machine(L2Cache, "Token protocol")
 
   action(f_sendExclusiveUnblock, "\f", desc="Send unblock to global directory") {
     enqueue(responseNetwork_out, ResponseMsg, response_latency) {
-      out_msg.Addr := address;
+      out_msg.addr := address;
       out_msg.Type := CoherenceResponseType:UNBLOCK_EXCLUSIVE;
       out_msg.Destination.add(map_Address_to_Directory(address));
       out_msg.Sender := machineID;
@@ -1168,7 +1168,7 @@ machine(L2Cache, "Token protocol")
 
   action(g_recordLocalSharer, "g", desc="Record new local sharer from unblock message") {
     peek(responseNetwork_in, ResponseMsg) {
-      recordLocalSharerInDir(cache_entry, in_msg.Addr, in_msg.Sender);
+      recordLocalSharerInDir(cache_entry, in_msg.addr, in_msg.Sender);
     }
   }
 
@@ -1184,13 +1184,13 @@ machine(L2Cache, "Token protocol")
 
   action(gg_clearSharerFromL1Response, "\gg", desc="Clear sharer from L1 response queue") {
     peek(responseNetwork_in, ResponseMsg) {
-      removeSharerFromDir(cache_entry, in_msg.Addr, in_msg.Sender);
+      removeSharerFromDir(cache_entry, in_msg.addr, in_msg.Sender);
     }
   }
 
   action(gg_clearOwnerFromL1Response, "g\g", desc="Clear sharer from L1 response queue") {
     peek(responseNetwork_in, ResponseMsg) {
-      removeOwnerFromDir(cache_entry, in_msg.Addr, in_msg.Sender);
+      removeOwnerFromDir(cache_entry, in_msg.addr, in_msg.Sender);
     }
   }
 
@@ -1239,11 +1239,11 @@ machine(L2Cache, "Token protocol")
   action(j_forwardGlobalRequestToLocalOwner, "j", desc="Forward external request to local owner") {
     peek(requestNetwork_in, RequestMsg) {
       enqueue( localRequestNetwork_out, RequestMsg, response_latency ) {
-        out_msg.Addr := in_msg.Addr;
+        out_msg.addr := in_msg.addr;
         out_msg.Type := in_msg.Type;
         out_msg.Requestor := machineID;
         out_msg.RequestorMachine := MachineType:L2Cache;
-        out_msg.Destination.add(getLocalOwner(cache_entry, in_msg.Addr));
+        out_msg.Destination.add(getLocalOwner(cache_entry, in_msg.addr));
         out_msg.Type := in_msg.Type;
         out_msg.MessageSize := MessageSizeType:Forwarded_Control;
         out_msg.Acks := 0 - 1;
@@ -1254,11 +1254,11 @@ machine(L2Cache, "Token protocol")
   action(jd_forwardDmaRequestToLocalOwner, "jd", desc="Forward dma request to local owner") {
     peek(requestNetwork_in, RequestMsg) {
       enqueue( localRequestNetwork_out, RequestMsg, response_latency ) {
-        out_msg.Addr := in_msg.Addr;
+        out_msg.addr := in_msg.addr;
         out_msg.Type := in_msg.Type;
         out_msg.Requestor := in_msg.Requestor;
         out_msg.RequestorMachine := in_msg.RequestorMachine;
-        out_msg.Destination.add(getLocalOwner(cache_entry, in_msg.Addr));
+        out_msg.Destination.add(getLocalOwner(cache_entry, in_msg.addr));
         out_msg.Type := in_msg.Type;
         out_msg.MessageSize := MessageSizeType:Forwarded_Control;
         out_msg.Acks := 0 - 1;
@@ -1270,12 +1270,12 @@ machine(L2Cache, "Token protocol")
   action(k_forwardLocalGETSToLocalSharer, "k", desc="Forward local request to local sharer/owner") {
     peek(L1requestNetwork_in, RequestMsg) {
       enqueue( localRequestNetwork_out, RequestMsg, response_latency ) {
-        out_msg.Addr := in_msg.Addr;
+        out_msg.addr := in_msg.addr;
         out_msg.Type := CoherenceRequestType:GETS;
         out_msg.Requestor := in_msg.Requestor;
         out_msg.RequestorMachine := MachineType:L1Cache;
         // should randomize this so one node doesn't get abused more than others
-        DirEntry dir_entry := getDirEntry(in_msg.Addr);
+        DirEntry dir_entry := getDirEntry(in_msg.addr);
         out_msg.Destination.add(dir_entry.Sharers.smallestElement(MachineType:L1Cache));
         out_msg.MessageSize := MessageSizeType:Forwarded_Control;
       }
@@ -1285,7 +1285,7 @@ machine(L2Cache, "Token protocol")
   action(k_forwardLocalGETXToLocalOwner, "\k", desc="Forward local request to local owner") {
     enqueue( localRequestNetwork_out, RequestMsg, response_latency ) {
       assert(is_valid(tbe));
-      out_msg.Addr := address;
+      out_msg.addr := address;
       out_msg.Type := CoherenceRequestType:GETX;
       out_msg.Requestor := tbe.L1_GetX_ID;
       out_msg.RequestorMachine := MachineType:L1Cache;
@@ -1300,11 +1300,11 @@ machine(L2Cache, "Token protocol")
   action(kk_forwardLocalGETXToLocalExclusive, "kk", desc="Forward local request to local owner") {
     peek(L1requestNetwork_in, RequestMsg) {
       enqueue( localRequestNetwork_out, RequestMsg, response_latency ) {
-        out_msg.Addr := in_msg.Addr;
+        out_msg.addr := in_msg.addr;
         out_msg.Type := CoherenceRequestType:GETX;
         out_msg.Requestor := in_msg.Requestor;
         out_msg.RequestorMachine := MachineType:L1Cache;
-        out_msg.Destination.add(getLocalOwner(cache_entry, in_msg.Addr));
+        out_msg.Destination.add(getLocalOwner(cache_entry, in_msg.addr));
         out_msg.MessageSize := MessageSizeType:Forwarded_Control;
         out_msg.Acks := 1;
       }
@@ -1314,11 +1314,11 @@ machine(L2Cache, "Token protocol")
   action(kk_forwardLocalGETSToLocalOwner, "\kk", desc="Forward local request to local owner") {
     peek(L1requestNetwork_in, RequestMsg) {
       enqueue( localRequestNetwork_out, RequestMsg, response_latency ) {
-        out_msg.Addr := in_msg.Addr;
+        out_msg.addr := in_msg.addr;
         out_msg.Type := CoherenceRequestType:GETS;
         out_msg.Requestor := in_msg.Requestor;
         out_msg.RequestorMachine := MachineType:L1Cache;
-        out_msg.Destination.add(getLocalOwner(cache_entry, in_msg.Addr));
+        out_msg.Destination.add(getLocalOwner(cache_entry, in_msg.addr));
         out_msg.MessageSize := MessageSizeType:Forwarded_Control;
       }
     }
@@ -1328,7 +1328,7 @@ machine(L2Cache, "Token protocol")
   action(l_writebackAckNeedData, "l", desc="Send writeback ack to L1 requesting data") {
     peek(L1requestNetwork_in, RequestMsg) {
       enqueue( localRequestNetwork_out, RequestMsg, response_latency ) {
-        out_msg.Addr := in_msg.Addr;
+        out_msg.addr := in_msg.addr;
         // out_msg.Type := CoherenceResponseType:WRITEBACK_SEND_DATA;
         out_msg.Type := CoherenceRequestType:WB_ACK_DATA;
         out_msg.Requestor := machineID;
@@ -1342,7 +1342,7 @@ machine(L2Cache, "Token protocol")
   action(l_writebackAckDropData, "\l", desc="Send writeback ack to L1 indicating to drop data") {
     peek(L1requestNetwork_in, RequestMsg) {
       enqueue( localRequestNetwork_out, RequestMsg, response_latency ) {
-        out_msg.Addr := in_msg.Addr;
+        out_msg.addr := in_msg.addr;
         // out_msg.Type := CoherenceResponseType:WRITEBACK_ACK;
         out_msg.Type := CoherenceRequestType:WB_ACK;
         out_msg.Requestor := machineID;
@@ -1356,7 +1356,7 @@ machine(L2Cache, "Token protocol")
   action(ll_writebackNack, "\ll", desc="Send writeback nack to L1") {
     peek(L1requestNetwork_in, RequestMsg) {
       enqueue( localRequestNetwork_out, RequestMsg, response_latency ) {
-        out_msg.Addr := in_msg.Addr;
+        out_msg.addr := in_msg.addr;
         out_msg.Type := CoherenceRequestType:WB_NACK;
         out_msg.Requestor := machineID;
         out_msg.RequestorMachine := MachineType:L2Cache;
@@ -1408,7 +1408,7 @@ machine(L2Cache, "Token protocol")
     assert(is_valid(tbe));
     if (tbe.NumIntPendingAcks == 0) {
       enqueue(triggerQueue_out, TriggerMsg) {
-        out_msg.Addr := address;
+        out_msg.addr := address;
         out_msg.Type := TriggerType:ALL_ACKS;
       }
     }
@@ -1418,7 +1418,7 @@ machine(L2Cache, "Token protocol")
     assert(is_valid(tbe));
     if (tbe.NumExtPendingAcks == 0) {
       enqueue(triggerQueue_out, TriggerMsg) {
-        out_msg.Addr := address;
+        out_msg.addr := address;
         out_msg.Type := TriggerType:ALL_ACKS;
       }
     }
@@ -1428,7 +1428,7 @@ machine(L2Cache, "Token protocol")
   action( qq_sendDataFromTBEToMemory, "qq", desc="Send data from TBE to directory") {
     enqueue(responseNetwork_out, ResponseMsg, response_latency) {
       assert(is_valid(tbe));
-      out_msg.Addr := address;
+      out_msg.addr := address;
       out_msg.Sender := machineID;
       out_msg.SenderMachine := MachineType:L2Cache;
       out_msg.Destination.add(map_Address_to_Directory(address));
@@ -1558,7 +1558,7 @@ machine(L2Cache, "Token protocol")
 
   action(da_sendDmaAckUnblock, "da", desc="Send dma ack to global directory") {
     enqueue(responseNetwork_out, ResponseMsg, response_latency) {
-      out_msg.Addr := address;
+      out_msg.addr := address;
       out_msg.Type := CoherenceResponseType:DMA_ACK;
       out_msg.Destination.add(map_Address_to_Directory(address));
       out_msg.Sender := machineID;