cpu: Add TraceCPU to playback elastic traces

[gem5.git] / src / mem / protocol / MOESI_CMP_token-L2cache.sm

diff --git a/src/mem/protocol/MOESI_CMP_token-L2cache.sm b/src/mem/protocol/MOESI_CMP_token-L2cache.sm
index ad746a27556eaecae5f37e6c4f4f5feb7883b469..2ab593394df6e5bd76c83d44dcb371ed8bf33202 100644 (file)
--- a/src/mem/protocol/MOESI_CMP_token-L2cache.sm
+++ b/src/mem/protocol/MOESI_CMP_token-L2cache.sm
@@ -38,28 +38,28 @@ machine(L2Cache, "Token protocol")
  
    // this L2 bank -> a local L1 || mod-directory
    MessageBuffer * responseFromL2Cache, network="To", virtual_network="4",
-        ordered="false", vnet_type="response";
+        vnet_type="response";
    // this L2 bank -> mod-directory
    MessageBuffer * GlobalRequestFromL2Cache, network="To", virtual_network="2",
-        ordered="false", vnet_type="request";
+        vnet_type="request";
    // this L2 bank -> a local L1
    MessageBuffer * L1RequestFromL2Cache, network="To", virtual_network="1",
-        ordered="false", vnet_type="request";
+        vnet_type="request";
  
  
    // FROM the network to this local bank of L2 cache
  
    // a local L1 || mod-directory -> this L2 bank
    MessageBuffer * responseToL2Cache, network="From", virtual_network="4",
-        ordered="false", vnet_type="response";
+        vnet_type="response";
    MessageBuffer * persistentToL2Cache, network="From", virtual_network="3",
-        ordered="true", vnet_type="persistent";
+        vnet_type="persistent";
    // mod-directory -> this L2 bank
    MessageBuffer * GlobalRequestToL2Cache, network="From", virtual_network="2",
-        ordered="false", vnet_type="request";
+        vnet_type="request";
    // a local L1 -> this L2 bank
    MessageBuffer * L1RequestToL2Cache, network="From", virtual_network="1",
-        ordered="false", vnet_type="request";
+        vnet_type="request";
 
 {
   // STATES
@@ -129,43 +129,44 @@ machine(L2Cache, "Token protocol")
   }
 
   structure(PerfectCacheMemory, external="yes") {
-    void allocate(Address);
-    void deallocate(Address);
-    DirEntry lookup(Address);
-    bool isTagPresent(Address);
+    void allocate(Addr);
+    void deallocate(Addr);
+    DirEntry lookup(Addr);
+    bool isTagPresent(Addr);
   }
 
   structure(PersistentTable, external="yes") {
-    void persistentRequestLock(Address, MachineID, AccessType);
-    void persistentRequestUnlock(Address, MachineID);
-    MachineID findSmallest(Address);
-    AccessType typeOfSmallest(Address);
-    void markEntries(Address);
-    bool isLocked(Address);
-    int countStarvingForAddress(Address);
-    int countReadStarvingForAddress(Address);
+    void persistentRequestLock(Addr, MachineID, AccessType);
+    void persistentRequestUnlock(Addr, MachineID);
+    MachineID findSmallest(Addr);
+    AccessType typeOfSmallest(Addr);
+    void markEntries(Addr);
+    bool isLocked(Addr);
+    int countStarvingForAddress(Addr);
+    int countReadStarvingForAddress(Addr);
   }
 
   PersistentTable persistentTable;
   PerfectCacheMemory localDirectory, template="<L2Cache_DirEntry>";
 
+  Tick clockEdge();
   void set_cache_entry(AbstractCacheEntry b);
   void unset_cache_entry();
 
-  Entry getCacheEntry(Address address), return_by_pointer="yes" {
+  Entry getCacheEntry(Addr address), return_by_pointer="yes" {
     Entry cache_entry := static_cast(Entry, "pointer", L2cache.lookup(address));
     return cache_entry;
   }
 
-  DirEntry getDirEntry(Address address), return_by_pointer="yes" {
+  DirEntry getDirEntry(Addr address), return_by_pointer="yes" {
     return localDirectory.lookup(address);
   }
 
-  void functionalRead(Address addr, Packet *pkt) {
+  void functionalRead(Addr addr, Packet *pkt) {
     testAndRead(addr, getCacheEntry(addr).DataBlk, pkt);
   }
 
-  int functionalWrite(Address addr, Packet *pkt) {
+  int functionalWrite(Addr addr, Packet *pkt) {
     int num_functional_writes := 0;
     num_functional_writes := num_functional_writes +
         testAndWrite(addr, getCacheEntry(addr).DataBlk, pkt);
@@ -180,7 +181,7 @@ machine(L2Cache, "Token protocol")
     }
   }
 
-  State getState(Entry cache_entry, Address addr) {
+  State getState(Entry cache_entry, Addr addr) {
     if (is_valid(cache_entry)) {
       return cache_entry.CacheState;
     } else if (persistentTable.isLocked(addr)) {
@@ -190,7 +191,7 @@ machine(L2Cache, "Token protocol")
     }
   }
 
-  void setState(Entry cache_entry, Address addr, State state) {
+  void setState(Entry cache_entry, Addr addr, State state) {
 
     if (is_valid(cache_entry)) {
       // Make sure the token count is in range
@@ -227,7 +228,7 @@ machine(L2Cache, "Token protocol")
     }
   }
 
-  AccessPermission getAccessPermission(Address addr) {
+  AccessPermission getAccessPermission(Addr addr) {
     Entry cache_entry := getCacheEntry(addr);
     if(is_valid(cache_entry)) {
       return L2Cache_State_to_permission(cache_entry.CacheState);
@@ -236,13 +237,13 @@ machine(L2Cache, "Token protocol")
     return AccessPermission:NotPresent;
   }
 
-  void setAccessPermission(Entry cache_entry, Address addr, State state) {
+  void setAccessPermission(Entry cache_entry, Addr addr, State state) {
     if (is_valid(cache_entry)) {
       cache_entry.changePermission(L2Cache_State_to_permission(state));
     }
   }
 
-  void removeSharer(Address addr, NodeID id) {
+  void removeSharer(Addr addr, NodeID id) {
 
     if (localDirectory.isTagPresent(addr)) {
       DirEntry dir_entry := getDirEntry(addr);
@@ -253,7 +254,7 @@ machine(L2Cache, "Token protocol")
     }
   }
 
-  bool sharersExist(Address addr) {
+  bool sharersExist(Addr addr) {
     if (localDirectory.isTagPresent(addr)) {
       DirEntry dir_entry := getDirEntry(addr);
       if (dir_entry.Sharers.count() > 0) {
@@ -268,7 +269,7 @@ machine(L2Cache, "Token protocol")
     }
   }
 
-  bool exclusiveExists(Address addr) {
+  bool exclusiveExists(Addr addr) {
     if (localDirectory.isTagPresent(addr)) {
       DirEntry dir_entry := getDirEntry(addr);
       if (dir_entry.exclusive) {
@@ -284,12 +285,12 @@ machine(L2Cache, "Token protocol")
   }
 
   // assumes that caller will check to make sure tag is present
-  Set getSharers(Address addr) {
+  Set getSharers(Addr addr) {
     DirEntry dir_entry := getDirEntry(addr);
     return dir_entry.Sharers;
   }
 
-  void setNewWriter(Address addr, NodeID id) {
+  void setNewWriter(Addr addr, NodeID id) {
     if (localDirectory.isTagPresent(addr) == false) {
       localDirectory.allocate(addr);
     }
@@ -299,7 +300,7 @@ machine(L2Cache, "Token protocol")
     dir_entry.exclusive := true;
   }
 
-  void addNewSharer(Address addr, NodeID id) {
+  void addNewSharer(Addr addr, NodeID id) {
     if (localDirectory.isTagPresent(addr) == false) {
       localDirectory.allocate(addr);
     }
@@ -308,7 +309,7 @@ machine(L2Cache, "Token protocol")
     // dir_entry.exclusive := false;
   }
 
-  void clearExclusiveBitIfExists(Address addr) {
+  void clearExclusiveBitIfExists(Addr addr) {
     if (localDirectory.isTagPresent(addr)) {
       DirEntry dir_entry := getDirEntry(addr);
       dir_entry.exclusive := false;
@@ -326,38 +327,38 @@ machine(L2Cache, "Token protocol")
 
   // Persistent Network
   in_port(persistentNetwork_in, PersistentMsg, persistentToL2Cache) {
-    if (persistentNetwork_in.isReady()) {
+    if (persistentNetwork_in.isReady(clockEdge())) {
       peek(persistentNetwork_in, PersistentMsg) {
         assert(in_msg.Destination.isElement(machineID));
 
         if (in_msg.Type == PersistentRequestType:GETX_PERSISTENT) {
-          persistentTable.persistentRequestLock(in_msg.Addr, 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.Addr, 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.Addr, in_msg.Requestor);
+          persistentTable.persistentRequestUnlock(in_msg.addr, in_msg.Requestor);
         } else {
           error("Unexpected message");
         }
 
-        Entry cache_entry := getCacheEntry(in_msg.Addr);
+        Entry cache_entry := getCacheEntry(in_msg.addr);
         // React to the message based on the current state of the table
-        if (persistentTable.isLocked(in_msg.Addr)) {
+        if (persistentTable.isLocked(in_msg.addr)) {
 
-          if (persistentTable.typeOfSmallest(in_msg.Addr) == 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.Addr,
+              trigger(Event:Persistent_GETS_Last_Token, in_msg.addr,
                       cache_entry);
             } else {
-              trigger(Event:Persistent_GETS, in_msg.Addr, cache_entry);
+              trigger(Event:Persistent_GETS, in_msg.addr, cache_entry);
             }
           } else {
-            trigger(Event:Persistent_GETX, in_msg.Addr, cache_entry);
+            trigger(Event:Persistent_GETX, in_msg.addr, cache_entry);
           }
         }
         else {
-            trigger(Event:Own_Lock_or_Unlock, in_msg.Addr, cache_entry);
+            trigger(Event:Own_Lock_or_Unlock, in_msg.addr, cache_entry);
         }
       }
     }
@@ -366,20 +367,20 @@ machine(L2Cache, "Token protocol")
 
   // Request Network
   in_port(requestNetwork_in, RequestMsg, GlobalRequestToL2Cache) {
-    if (requestNetwork_in.isReady()) {
+    if (requestNetwork_in.isReady(clockEdge())) {
       peek(requestNetwork_in, RequestMsg) {
         assert(in_msg.Destination.isElement(machineID));
 
-        Entry cache_entry := getCacheEntry(in_msg.Addr);
+        Entry cache_entry := getCacheEntry(in_msg.addr);
         if (in_msg.Type == CoherenceRequestType:GETX) {
-            trigger(Event:Transient_GETX, in_msg.Addr, 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.Addr,
+            trigger(Event:Transient_GETS_Last_Token, in_msg.addr,
                     cache_entry);
           }
           else {
-            trigger(Event:Transient_GETS, in_msg.Addr, cache_entry);
+            trigger(Event:Transient_GETS, in_msg.addr, cache_entry);
           }
         } else {
           error("Unexpected message");
@@ -389,19 +390,19 @@ machine(L2Cache, "Token protocol")
   }
 
   in_port(L1requestNetwork_in, RequestMsg, L1RequestToL2Cache) {
-    if (L1requestNetwork_in.isReady()) {
+    if (L1requestNetwork_in.isReady(clockEdge())) {
       peek(L1requestNetwork_in, RequestMsg) {
         assert(in_msg.Destination.isElement(machineID));
-        Entry cache_entry := getCacheEntry(in_msg.Addr);
+        Entry cache_entry := getCacheEntry(in_msg.addr);
         if (in_msg.Type == CoherenceRequestType:GETX) {
-          trigger(Event:L1_GETX, in_msg.Addr, 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.Addr, cache_entry);
+            trigger(Event:L1_GETS_Last_Token, in_msg.addr, cache_entry);
           }
           else {
-            trigger(Event:L1_GETS, in_msg.Addr, cache_entry);
+            trigger(Event:L1_GETS, in_msg.addr, cache_entry);
           }
         } else {
           error("Unexpected message");
@@ -413,83 +414,83 @@ machine(L2Cache, "Token protocol")
 
   // Response Network
   in_port(responseNetwork_in, ResponseMsg, responseToL2Cache) {
-    if (responseNetwork_in.isReady()) {
+    if (responseNetwork_in.isReady(clockEdge())) {
       peek(responseNetwork_in, ResponseMsg) {
         assert(in_msg.Destination.isElement(machineID));
-        Entry cache_entry := getCacheEntry(in_msg.Addr);
+        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.Addr, cache_entry);
+            trigger(Event:Ack, in_msg.addr, cache_entry);
           } else if (in_msg.Type == CoherenceResponseType:DATA_OWNER) {
-            trigger(Event:Data_Owner, in_msg.Addr, 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.Addr, 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.Addr) || 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.Addr, 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.Addr, 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.Addr, cache_entry);
+                trigger(Event:Writeback_Owned, in_msg.addr, cache_entry);
               }
             }
             else {
                 trigger(Event:L2_Replacement,
-                        L2cache.cacheProbe(in_msg.Addr),
-                        getCacheEntry(L2cache.cacheProbe(in_msg.Addr)));
+                        L2cache.cacheProbe(in_msg.addr),
+                        getCacheEntry(L2cache.cacheProbe(in_msg.addr)));
             }
           } else if (in_msg.Type == CoherenceResponseType:INV) {
-            trigger(Event:L1_INV, in_msg.Addr, 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.Addr, 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.Addr, 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.Addr) || 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.Addr) != State:NP)
-                      && (getState(cache_entry, in_msg.Addr) != State:I) );
-                trigger(Event:Writeback_All_Tokens, in_msg.Addr, 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.Addr, 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.Addr, cache_entry);
+                trigger(Event:Writeback_All_Tokens, in_msg.addr, cache_entry);
               }
             }
             else {
                 trigger(Event:L2_Replacement,
-                        L2cache.cacheProbe(in_msg.Addr),
-                        getCacheEntry(L2cache.cacheProbe(in_msg.Addr)));
+                        L2cache.cacheProbe(in_msg.addr),
+                        getCacheEntry(L2cache.cacheProbe(in_msg.addr)));
             }
           } else if (in_msg.Type == CoherenceResponseType:INV) {
-            trigger(Event:L1_INV, in_msg.Addr, cache_entry);
+            trigger(Event:L1_INV, in_msg.addr, cache_entry);
           } else {
             DPRINTF(RubySlicc, "%s\n", in_msg.Type);
             error("Unexpected message");
@@ -508,7 +509,7 @@ machine(L2Cache, "Token protocol")
 
      // if this is a retry or no local sharers, broadcast normally
         enqueue(globalRequestNetwork_out, RequestMsg, l2_request_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.RetryNum := in_msg.RetryNum;
@@ -537,7 +538,7 @@ machine(L2Cache, "Token protocol")
     peek(responseNetwork_in, ResponseMsg) {
       // FIXME, should use a 3rd vnet
       enqueue(responseNetwork_out, ResponseMsg, 1) {
-        out_msg.Addr := address;
+        out_msg.addr := address;
         out_msg.Type := in_msg.Type;
         out_msg.Sender := machineID;
         out_msg.Destination.add(map_Address_to_Directory(address));
@@ -553,7 +554,7 @@ machine(L2Cache, "Token protocol")
     assert(is_valid(cache_entry));
     if (cache_entry.Tokens > 0) {
       enqueue(responseNetwork_out, ResponseMsg, l2_response_latency) {
-        out_msg.Addr := address;
+        out_msg.addr := address;
         out_msg.Type := CoherenceResponseType:ACK;
         out_msg.Sender := machineID;
         out_msg.Destination.add(map_Address_to_Directory(address));
@@ -567,7 +568,7 @@ machine(L2Cache, "Token protocol")
   action(cc_dirtyReplacement, "\c", desc="Issue dirty writeback") {
     assert(is_valid(cache_entry));
     enqueue(responseNetwork_out, ResponseMsg, l2_response_latency) {
-      out_msg.Addr := address;
+      out_msg.addr := address;
       out_msg.Sender := machineID;
       out_msg.Destination.add(map_Address_to_Directory(address));
       out_msg.Tokens := cache_entry.Tokens;
@@ -590,7 +591,7 @@ machine(L2Cache, "Token protocol")
       assert(is_valid(cache_entry));
       if (cache_entry.Tokens > (N_tokens + (max_tokens() / 2))) {
         enqueue(responseNetwork_out, ResponseMsg, l2_response_latency) {
-          out_msg.Addr := address;
+          out_msg.addr := address;
           out_msg.Type := CoherenceResponseType:DATA_SHARED;
           out_msg.Sender := machineID;
           out_msg.Destination.add(in_msg.Requestor);
@@ -603,7 +604,7 @@ machine(L2Cache, "Token protocol")
       }
       else {
         enqueue(responseNetwork_out, ResponseMsg, l2_response_latency) {
-          out_msg.Addr := address;
+          out_msg.addr := address;
           out_msg.Type := CoherenceResponseType:DATA_SHARED;
           out_msg.Sender := machineID;
           out_msg.Destination.add(in_msg.Requestor);
@@ -621,7 +622,7 @@ machine(L2Cache, "Token protocol")
     assert(is_valid(cache_entry));
     peek(requestNetwork_in, RequestMsg) {
       enqueue(responseNetwork_out, ResponseMsg, l2_response_latency) {
-        out_msg.Addr := address;
+        out_msg.addr := address;
         out_msg.Type := CoherenceResponseType:DATA_OWNER;
         out_msg.Sender := machineID;
         out_msg.Destination.add(in_msg.Requestor);
@@ -639,7 +640,7 @@ machine(L2Cache, "Token protocol")
     assert(is_valid(cache_entry));
     if (cache_entry.Tokens > 0) {
       enqueue(responseNetwork_out, ResponseMsg, l2_response_latency) {
-        out_msg.Addr := address;
+        out_msg.addr := address;
         out_msg.Type := CoherenceResponseType:ACK;
         out_msg.Sender := machineID;
         out_msg.Destination.add(persistentTable.findSmallest(address));
@@ -654,7 +655,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, l2_response_latency) {
-      out_msg.Addr := address;
+      out_msg.addr := address;
       out_msg.Type := CoherenceResponseType:DATA_OWNER;
       out_msg.Sender := machineID;
       out_msg.Destination.add(persistentTable.findSmallest(address));
@@ -673,7 +674,7 @@ machine(L2Cache, "Token protocol")
     assert(cache_entry.Tokens > 0);
     if (cache_entry.Tokens > 1) {
       enqueue(responseNetwork_out, ResponseMsg, l2_response_latency) {
-        out_msg.Addr := address;
+        out_msg.addr := address;
         out_msg.Type := CoherenceResponseType:ACK;
         out_msg.Sender := machineID;
         out_msg.Destination.add(persistentTable.findSmallest(address));
@@ -690,7 +691,7 @@ machine(L2Cache, "Token protocol")
     assert(is_valid(cache_entry));
     assert(cache_entry.Tokens > (max_tokens() / 2) + 1);
     enqueue(responseNetwork_out, ResponseMsg, l2_response_latency) {
-        out_msg.Addr := address;
+        out_msg.addr := address;
         out_msg.Type := CoherenceResponseType:DATA_OWNER;
         out_msg.Sender := machineID;
         out_msg.Destination.add(persistentTable.findSmallest(address));
@@ -707,7 +708,7 @@ machine(L2Cache, "Token protocol")
     assert(is_valid(cache_entry));
     assert(cache_entry.Tokens == (max_tokens() / 2) + 1);
     enqueue(responseNetwork_out, ResponseMsg, l2_response_latency) {
-        out_msg.Addr := address;
+        out_msg.addr := address;
         out_msg.Type := CoherenceResponseType:DATA_OWNER;
         out_msg.Sender := machineID;
         out_msg.Destination.add(persistentTable.findSmallest(address));
@@ -726,7 +727,7 @@ machine(L2Cache, "Token protocol")
     peek(responseNetwork_in, ResponseMsg) {
       // FIXME, should use a 3rd vnet in some cases
       enqueue(responseNetwork_out, ResponseMsg, 1) {
-        out_msg.Addr := address;
+        out_msg.addr := address;
         out_msg.Type := in_msg.Type;
         out_msg.Sender := machineID;
         out_msg.Destination.add(persistentTable.findSmallest(address));
@@ -743,7 +744,7 @@ machine(L2Cache, "Token protocol")
     peek(responseNetwork_in, ResponseMsg) {
       // FIXME, should use a 3rd vnet in some cases
       enqueue(responseNetwork_out, ResponseMsg, 1) {
-        out_msg.Addr := address;
+        out_msg.addr := address;
         if (in_msg.Type == CoherenceResponseType:WB_SHARED_DATA) {
           out_msg.Type := CoherenceResponseType:DATA_SHARED;
         } else {
@@ -765,7 +766,7 @@ machine(L2Cache, "Token protocol")
     peek(responseNetwork_in, ResponseMsg) {
       // FIXME, should use a 3rd vnet in some cases
       enqueue(responseNetwork_out, ResponseMsg, 1) {
-        out_msg.Addr := address;
+        out_msg.addr := address;
         out_msg.Type := CoherenceResponseType:DATA_OWNER;
         out_msg.Sender := machineID;
         out_msg.Destination.add(persistentTable.findSmallest(address));
@@ -780,20 +781,20 @@ machine(L2Cache, "Token protocol")
 
   action(h_updateFilterFromL1HintOrWB, "h", desc="update filter from received writeback") {
     peek(responseNetwork_in, ResponseMsg) {
-      removeSharer(in_msg.Addr, 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 && in_msg.RetryNum == 0 && sharersExist(in_msg.Addr) == false) {
+      if (filtering_enabled && 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, l2_response_latency ) {
-           out_msg.Addr := in_msg.Addr;
+           out_msg.addr := in_msg.addr;
            out_msg.Requestor := in_msg.Requestor;
 
            //
@@ -819,7 +820,7 @@ machine(L2Cache, "Token protocol")
       assert(is_valid(cache_entry));
       assert(cache_entry.Tokens > 0);
       enqueue(responseNetwork_out, ResponseMsg, l2_response_latency) {
-        out_msg.Addr := address;
+        out_msg.addr := address;
         out_msg.Type := CoherenceResponseType:DATA_SHARED;
         out_msg.Sender := machineID;
         out_msg.Destination.add(in_msg.Requestor);
@@ -837,7 +838,7 @@ machine(L2Cache, "Token protocol")
       assert(is_valid(cache_entry));
       assert(cache_entry.Tokens == (max_tokens() / 2) + 1);
       enqueue(responseNetwork_out, ResponseMsg, l2_response_latency) {
-        out_msg.Addr := address;
+        out_msg.addr := address;
         out_msg.Type := CoherenceResponseType:DATA_OWNER;
         out_msg.Sender := machineID;
         out_msg.Destination.add(in_msg.Requestor);
@@ -855,7 +856,7 @@ machine(L2Cache, "Token protocol")
       assert(is_valid(cache_entry));
 //      assert(cache_entry.Tokens == max_tokens());
       enqueue(responseNetwork_out, ResponseMsg, l2_response_latency) {
-        out_msg.Addr := address;
+        out_msg.addr := address;
         out_msg.Type := CoherenceResponseType:DATA_OWNER;
         out_msg.Sender := machineID;
         out_msg.Destination.add(in_msg.Requestor);
@@ -870,19 +871,19 @@ machine(L2Cache, "Token protocol")
   }
 
   action(l_popPersistentQueue, "l", desc="Pop persistent queue.") {
-    persistentNetwork_in.dequeue();
+    persistentNetwork_in.dequeue(clockEdge());
   }
 
   action(m_popRequestQueue, "m", desc="Pop request queue.") {
-    requestNetwork_in.dequeue();
+    requestNetwork_in.dequeue(clockEdge());
   }
 
   action(n_popResponseQueue, "n", desc="Pop response queue") {
-    responseNetwork_in.dequeue();
+    responseNetwork_in.dequeue(clockEdge());
   }
 
   action(o_popL1RequestQueue, "o", desc="Pop L1 request queue.") {
-    L1requestNetwork_in.dequeue();
+    L1requestNetwork_in.dequeue(clockEdge());
   }
 
 
@@ -904,9 +905,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.Addr, machineIDToNodeID(in_msg.Requestor));
+          setNewWriter(in_msg.addr, machineIDToNodeID(in_msg.Requestor));
         } else if (in_msg.Type == CoherenceRequestType:GETS) {
-          addNewSharer(in_msg.Addr, machineIDToNodeID(in_msg.Requestor));
+          addNewSharer(in_msg.addr, machineIDToNodeID(in_msg.Requestor));
         }
       }
     }
@@ -930,7 +931,7 @@ machine(L2Cache, "Token protocol")
     if (cache_entry.Tokens > 0) {
       peek(requestNetwork_in, RequestMsg) {
         enqueue(responseNetwork_out, ResponseMsg, l2_response_latency) {
-          out_msg.Addr := address;
+          out_msg.addr := address;
           out_msg.Type := CoherenceResponseType:ACK;
           out_msg.Sender := machineID;
           out_msg.Destination.add(in_msg.Requestor);
@@ -948,7 +949,7 @@ machine(L2Cache, "Token protocol")
     if (cache_entry.Tokens > 0) {
       peek(L1requestNetwork_in, RequestMsg) {
         enqueue(responseNetwork_out, ResponseMsg, l2_response_latency) {
-          out_msg.Addr := address;
+          out_msg.addr := address;
           out_msg.Type := CoherenceResponseType:ACK;
           out_msg.Sender := machineID;
           out_msg.Destination.add(in_msg.Requestor);