From 7c39d5df7ea61a39ad1b9a3aa70d22f0e2943b21 Mon Sep 17 00:00:00 2001 From: Lena Olson Date: Tue, 18 Jun 2013 16:58:33 -0500 Subject: 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 --- src/mem/protocol/MOESI_CMP_token-L2cache.sm | 132 ++++++++++++++-------------- 1 file changed, 66 insertions(+), 66 deletions(-) (limited to '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 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); -- cgit v1.2.3