| /* |
| * Copyright (c) 2012-2015 Advanced Micro Devices, Inc. |
| * All rights reserved. |
| * |
| * For use for simulation and test purposes only |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions are met: |
| * |
| * 1. Redistributions of source code must retain the above copyright notice, |
| * this list of conditions and the following disclaimer. |
| * |
| * 2. Redistributions in binary form must reproduce the above copyright notice, |
| * this list of conditions and the following disclaimer in the documentation |
| * and/or other materials provided with the distribution. |
| * |
| * 3. Neither the name of the copyright holder nor the names of its contributors |
| * may be used to endorse or promote products derived from this software |
| * without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
| * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE |
| * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
| * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
| * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS |
| * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
| * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
| * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE |
| * POSSIBILITY OF SUCH DAMAGE. |
| * |
| * Author: Mithuna Thottethodi |
| */ |
| |
| machine(MachineType:TCCdir, "AMD read-for-ownership directory for TCC (aka GPU L2)") |
| : CacheMemory * directory; |
| // Convention: wire buffers are prefixed with "w_" for clarity |
| WireBuffer * w_reqToTCCDir; |
| WireBuffer * w_respToTCCDir; |
| WireBuffer * w_TCCUnblockToTCCDir; |
| WireBuffer * w_reqToTCC; |
| WireBuffer * w_probeToTCC; |
| WireBuffer * w_respToTCC; |
| int TCC_select_num_bits; |
| Cycles response_latency := 5; |
| Cycles directory_latency := 6; |
| Cycles issue_latency := 120; |
| |
| // From the TCPs or SQCs |
| MessageBuffer * requestFromTCP, network="From", virtual_network="1", vnet_type="request"; |
| MessageBuffer * responseFromTCP, network="From", virtual_network="3", vnet_type="response"; |
| MessageBuffer * unblockFromTCP, network="From", virtual_network="5", vnet_type="unblock"; |
| |
| // To the Cores. TCC deals only with TCPs/SQCs. CP cores do not communicate directly with TCC. |
| MessageBuffer * probeToCore, network="To", virtual_network="1", vnet_type="request"; |
| MessageBuffer * responseToCore, network="To", virtual_network="3", vnet_type="response"; |
| |
| // From the NB |
| MessageBuffer * probeFromNB, network="From", virtual_network="0", vnet_type="request"; |
| MessageBuffer * responseFromNB, network="From", virtual_network="2", vnet_type="response"; |
| // To the NB |
| MessageBuffer * requestToNB, network="To", virtual_network="0", vnet_type="request"; |
| MessageBuffer * responseToNB, network="To", virtual_network="2", vnet_type="response"; |
| MessageBuffer * unblockToNB, network="To", virtual_network="4", vnet_type="unblock"; |
| |
| MessageBuffer * triggerQueue, random="false"; |
| { |
| // STATES |
| state_declaration(State, desc="Directory states", default="TCCdir_State_I") { |
| // Base states |
| I, AccessPermission:Invalid, desc="Invalid"; |
| S, AccessPermission:Invalid, desc="Shared"; |
| E, AccessPermission:Invalid, desc="Shared"; |
| O, AccessPermission:Invalid, desc="Owner"; |
| M, AccessPermission:Invalid, desc="Modified"; |
| |
| CP_I, AccessPermission:Invalid, desc="Blocked, must send data after acks are in, going to invalid"; |
| B_I, AccessPermission:Invalid, desc="Blocked, need not send data after acks are in, going to invalid"; |
| CP_O, AccessPermission:Invalid, desc="Blocked, must send data after acks are in, going to owned"; |
| CP_S, AccessPermission:Invalid, desc="Blocked, must send data after acks are in, going to shared"; |
| CP_OM, AccessPermission:Invalid, desc="Blocked, must send data after acks are in, going to O_M"; |
| CP_SM, AccessPermission:Invalid, desc="Blocked, must send data after acks are in, going to S_M"; |
| CP_ISM, AccessPermission:Invalid, desc="Blocked, must send data after acks are in, going to I_M"; |
| CP_IOM, AccessPermission:Invalid, desc="Blocked, must send data after acks are in, going to I_M"; |
| CP_OSIW, AccessPermission:Invalid, desc="Blocked, must send data after acks+CancelWB are in, going to I_C"; |
| |
| |
| // Transient states and busy states used for handling side (TCC-facing) interactions |
| BW_S, AccessPermission:Invalid, desc="Blocked, Awaiting TCC unblock"; |
| BW_E, AccessPermission:Invalid, desc="Blocked, Awaiting TCC unblock"; |
| BW_O, AccessPermission:Invalid, desc="Blocked, Awaiting TCC unblock"; |
| BW_M, AccessPermission:Invalid, desc="Blocked, Awaiting TCC unblock"; |
| |
| // Transient states and busy states used for handling upward (TCP-facing) interactions |
| I_M, AccessPermission:Invalid, desc="Invalid, issued RdBlkM, have not seen response yet"; |
| I_ES, AccessPermission:Invalid, desc="Invalid, issued RdBlk, have not seen response yet"; |
| I_S, AccessPermission:Invalid, desc="Invalid, issued RdBlkS, have not seen response yet"; |
| BBS_S, AccessPermission:Invalid, desc="Blocked, going from S to S"; |
| BBO_O, AccessPermission:Invalid, desc="Blocked, going from O to O"; |
| BBM_M, AccessPermission:Invalid, desc="Blocked, going from M to M, waiting for data to forward"; |
| BBM_O, AccessPermission:Invalid, desc="Blocked, going from M to O, waiting for data to forward"; |
| BB_M, AccessPermission:Invalid, desc="Blocked, going from M to M, waiting for unblock"; |
| BB_O, AccessPermission:Invalid, desc="Blocked, going from M to O, waiting for unblock"; |
| BB_OO, AccessPermission:Invalid, desc="Blocked, going from O to O (adding sharers), waiting for unblock"; |
| BB_S, AccessPermission:Invalid, desc="Blocked, going to S, waiting for (possible multiple) unblock(s)"; |
| BBS_M, AccessPermission:Invalid, desc="Blocked, going from S or O to M"; |
| BBO_M, AccessPermission:Invalid, desc="Blocked, going from S or O to M"; |
| BBS_UM, AccessPermission:Invalid, desc="Blocked, going from S or O to M via upgrade"; |
| BBO_UM, AccessPermission:Invalid, desc="Blocked, going from S or O to M via upgrade"; |
| S_M, AccessPermission:Invalid, desc="Shared, issued CtoD, have not seen response yet"; |
| O_M, AccessPermission:Invalid, desc="Shared, issued CtoD, have not seen response yet"; |
| |
| // |
| BBB_S, AccessPermission:Invalid, desc="Blocked, going to S after core unblock"; |
| BBB_M, AccessPermission:Invalid, desc="Blocked, going to M after core unblock"; |
| BBB_E, AccessPermission:Invalid, desc="Blocked, going to E after core unblock"; |
| |
| VES_I, AccessPermission:Invalid, desc="TCC replacement, waiting for clean WB ack"; |
| VM_I, AccessPermission:Invalid, desc="TCC replacement, waiting for dirty WB ack"; |
| VO_I, AccessPermission:Invalid, desc="TCC replacement, waiting for dirty WB ack"; |
| VO_S, AccessPermission:Invalid, desc="TCC owner replacement, waiting for dirty WB ack"; |
| |
| ES_I, AccessPermission:Invalid, desc="L1 replacement, waiting for clean WB ack"; |
| MO_I, AccessPermission:Invalid, desc="L1 replacement, waiting for dirty WB ack"; |
| |
| I_C, AccessPermission:Invalid, desc="Invalid, waiting for WBAck from NB for canceled WB"; |
| I_W, AccessPermission:Invalid, desc="Invalid, waiting for WBAck from NB; canceled WB raced with directory invalidation"; |
| |
| // Recall States |
| BRWD_I, AccessPermission:Invalid, desc="Recalling, waiting for WBAck and Probe Data responses"; |
| BRW_I, AccessPermission:Read_Write, desc="Recalling, waiting for WBAck"; |
| BRD_I, AccessPermission:Invalid, desc="Recalling, waiting for Probe Data responses"; |
| |
| } |
| |
| enumeration(RequestType, desc="To communicate stats from transitions to recordStats") { |
| DataArrayRead, desc="Read the data array"; |
| DataArrayWrite, desc="Write the data array"; |
| TagArrayRead, desc="Read the data array"; |
| TagArrayWrite, desc="Write the data array"; |
| } |
| |
| |
| |
| // EVENTS |
| enumeration(Event, desc="TCC Directory Events") { |
| // Upward facing events (TCCdir w.r.t. TCP/SQC and TCC behaves like NBdir behaves with TCP/SQC and L3 |
| |
| // Directory Recall |
| Recall, desc="directory cache is full"; |
| // CPU requests |
| CPUWrite, desc="Initial req from core, sent to TCC"; |
| NoCPUWrite, desc="Initial req from core, but non-exclusive clean data; can be discarded"; |
| CPUWriteCancel, desc="Initial req from core, sent to TCC"; |
| |
| // Requests from the TCPs |
| RdBlk, desc="RdBlk event"; |
| RdBlkM, desc="RdBlkM event"; |
| RdBlkS, desc="RdBlkS event"; |
| CtoD, desc="Change to Dirty request"; |
| |
| // TCC writebacks |
| VicDirty, desc="..."; |
| VicDirtyLast, desc="..."; |
| VicClean, desc="..."; |
| NoVic, desc="..."; |
| StaleVic, desc="..."; |
| CancelWB, desc="TCC got invalidating probe, canceled WB"; |
| |
| // Probe Responses from TCP/SQCs |
| CPUPrbResp, desc="Probe response from TCP/SQC"; |
| TCCPrbResp, desc="Probe response from TCC"; |
| |
| ProbeAcksComplete, desc="All acks received"; |
| ProbeAcksCompleteReissue, desc="All acks received, changing CtoD to reissue"; |
| |
| CoreUnblock, desc="unblock from TCP/SQC"; |
| LastCoreUnblock, desc="Last unblock from TCP/SQC"; |
| TCCUnblock, desc="unblock from TCC (current owner)"; |
| TCCUnblock_Sharer, desc="unblock from TCC (a sharer, not owner)"; |
| TCCUnblock_NotValid,desc="unblock from TCC (not valid...caused by stale writebacks)"; |
| |
| // Downward facing events |
| |
| // NB initiated |
| NB_AckS, desc="NB Ack to TCC Request"; |
| NB_AckE, desc="NB Ack to TCC Request"; |
| NB_AckM, desc="NB Ack to TCC Request"; |
| NB_AckCtoD, desc="NB Ack to TCC Request"; |
| NB_AckWB, desc="NB Ack for clean WB"; |
| |
| |
| // Incoming Probes from NB |
| PrbInvData, desc="Invalidating probe, return dirty data"; |
| PrbInv, desc="Invalidating probe, no need to return data"; |
| PrbShrData, desc="Downgrading probe, return data"; |
| } |
| |
| |
| // TYPES |
| |
| // Entry for directory |
| structure(Entry, desc="...", interface='AbstractCacheEntry') { |
| State CacheState, desc="Cache state (Cache of directory entries)"; |
| DataBlock DataBlk, desc="data for the block"; |
| NetDest Sharers, desc="Sharers for this block"; |
| NetDest Owner, desc="Owner of this block"; |
| NetDest MergedSharers, desc="Read sharers who are merged on a request"; |
| int WaitingUnblocks, desc="Number of acks we're waiting for"; |
| } |
| |
| structure(TBE, desc="...") { |
| State TBEState, desc="Transient state"; |
| DataBlock DataBlk, desc="DataBlk"; |
| bool Dirty, desc="Is the data dirty?"; |
| MachineID Requestor, desc="requestor"; |
| int NumPendingAcks, desc="num acks expected"; |
| MachineID OriginalRequestor, desc="Original Requestor"; |
| MachineID UntransferredOwner, desc = "Untransferred owner for an upgrade transaction"; |
| bool UntransferredOwnerExists, desc = "1 if Untransferred owner exists for an upgrade transaction"; |
| bool Cached, desc="data hit in Cache"; |
| bool Shared, desc="victim hit by shared probe"; |
| bool Upgrade, desc="An upgrade request in progress"; |
| bool CtoD, desc="Saved sysack info"; |
| CoherenceState CohState, desc="Saved sysack info"; |
| MessageSizeType MessageSize, desc="Saved sysack info"; |
| MachineID Sender, desc="sender"; |
| } |
| |
| structure(TBETable, external = "yes") { |
| TBE lookup(Addr); |
| void allocate(Addr); |
| void deallocate(Addr); |
| bool isPresent(Addr); |
| } |
| |
| // ** OBJECTS ** |
| TBETable TBEs, template="<TCCdir_TBE>", constructor="m_number_of_TBEs"; |
| int TCC_select_low_bit, default="RubySystem::getBlockSizeBits()"; |
| NetDest TCC_dir_subtree; |
| NetDest temp; |
| |
| Tick clockEdge(); |
| Tick cyclesToTicks(Cycles c); |
| |
| void set_cache_entry(AbstractCacheEntry b); |
| void unset_cache_entry(); |
| void set_tbe(TBE b); |
| void unset_tbe(); |
| |
| |
| bool presentOrAvail(Addr addr) { |
| return directory.isTagPresent(addr) || directory.cacheAvail(addr); |
| } |
| |
| Entry getCacheEntry(Addr addr), return_by_pointer="yes" { |
| return static_cast(Entry, "pointer", directory.lookup(addr)); |
| } |
| |
| DataBlock getDataBlock(Addr addr), return_by_ref="yes" { |
| TBE tbe := TBEs.lookup(addr); |
| if(is_valid(tbe)) { |
| return tbe.DataBlk; |
| } else { |
| assert(false); |
| return getCacheEntry(addr).DataBlk; |
| } |
| } |
| |
| State getState(TBE tbe, Entry cache_entry, Addr addr) { |
| if(is_valid(tbe)) { |
| return tbe.TBEState; |
| } else if (is_valid(cache_entry)) { |
| return cache_entry.CacheState; |
| } |
| return State:I; |
| } |
| |
| void setAccessPermission(Entry cache_entry, Addr addr, State state) { |
| if (is_valid(cache_entry)) { |
| cache_entry.changePermission(TCCdir_State_to_permission(state)); |
| } |
| } |
| |
| AccessPermission getAccessPermission(Addr addr) { |
| TBE tbe := TBEs.lookup(addr); |
| if(is_valid(tbe)) { |
| return TCCdir_State_to_permission(tbe.TBEState); |
| } |
| |
| Entry cache_entry := getCacheEntry(addr); |
| if(is_valid(cache_entry)) { |
| return TCCdir_State_to_permission(cache_entry.CacheState); |
| } |
| |
| return AccessPermission:NotPresent; |
| } |
| |
| void functionalRead(Addr addr, Packet *pkt) { |
| TBE tbe := TBEs.lookup(addr); |
| if(is_valid(tbe)) { |
| testAndRead(addr, tbe.DataBlk, pkt); |
| } else { |
| functionalMemoryRead(pkt); |
| } |
| } |
| |
| int functionalWrite(Addr addr, Packet *pkt) { |
| int num_functional_writes := 0; |
| |
| TBE tbe := TBEs.lookup(addr); |
| if(is_valid(tbe)) { |
| num_functional_writes := num_functional_writes + |
| testAndWrite(addr, tbe.DataBlk, pkt); |
| } |
| |
| num_functional_writes := num_functional_writes + functionalMemoryWrite(pkt); |
| return num_functional_writes; |
| } |
| |
| void setState(TBE tbe, Entry cache_entry, Addr addr, State state) { |
| if (is_valid(tbe)) { |
| tbe.TBEState := state; |
| } |
| |
| if (is_valid(cache_entry)) { |
| cache_entry.CacheState := state; |
| |
| if (state == State:S) { |
| assert(cache_entry.Owner.count() == 0); |
| } |
| |
| if (state == State:O) { |
| assert(cache_entry.Owner.count() == 1); |
| assert(cache_entry.Sharers.isSuperset(cache_entry.Owner) == false); |
| } |
| |
| if (state == State:M) { |
| assert(cache_entry.Owner.count() == 1); |
| assert(cache_entry.Sharers.count() == 0); |
| } |
| |
| if (state == State:E) { |
| assert(cache_entry.Owner.count() == 0); |
| assert(cache_entry.Sharers.count() == 1); |
| } |
| } |
| } |
| |
| |
| |
| void recordRequestType(RequestType request_type, Addr addr) { |
| if (request_type == RequestType:DataArrayRead) { |
| directory.recordRequestType(CacheRequestType:DataArrayRead, addr); |
| } else if (request_type == RequestType:DataArrayWrite) { |
| directory.recordRequestType(CacheRequestType:DataArrayWrite, addr); |
| } else if (request_type == RequestType:TagArrayRead) { |
| directory.recordRequestType(CacheRequestType:TagArrayRead, addr); |
| } else if (request_type == RequestType:TagArrayWrite) { |
| directory.recordRequestType(CacheRequestType:TagArrayWrite, addr); |
| } |
| } |
| |
| bool checkResourceAvailable(RequestType request_type, Addr addr) { |
| if (request_type == RequestType:DataArrayRead) { |
| return directory.checkResourceAvailable(CacheResourceType:DataArray, addr); |
| } else if (request_type == RequestType:DataArrayWrite) { |
| return directory.checkResourceAvailable(CacheResourceType:DataArray, addr); |
| } else if (request_type == RequestType:TagArrayRead) { |
| return directory.checkResourceAvailable(CacheResourceType:TagArray, addr); |
| } else if (request_type == RequestType:TagArrayWrite) { |
| return directory.checkResourceAvailable(CacheResourceType:TagArray, addr); |
| } else { |
| error("Invalid RequestType type in checkResourceAvailable"); |
| return true; |
| } |
| } |
| |
| // ** OUT_PORTS ** |
| |
| // Three classes of ports |
| // Class 1: downward facing network links to NB |
| out_port(requestToNB_out, CPURequestMsg, requestToNB); |
| out_port(responseToNB_out, ResponseMsg, responseToNB); |
| out_port(unblockToNB_out, UnblockMsg, unblockToNB); |
| |
| |
| // Class 2: upward facing ports to GPU cores |
| out_port(probeToCore_out, TDProbeRequestMsg, probeToCore); |
| out_port(responseToCore_out, ResponseMsg, responseToCore); |
| |
| // Class 3: sideward facing ports (on "wirebuffer" links) to TCC |
| out_port(w_requestTCC_out, CPURequestMsg, w_reqToTCC); |
| out_port(w_probeTCC_out, NBProbeRequestMsg, w_probeToTCC); |
| out_port(w_respTCC_out, ResponseMsg, w_respToTCC); |
| |
| |
| // local trigger port |
| out_port(triggerQueue_out, TriggerMsg, triggerQueue); |
| |
| // |
| // request queue going to NB |
| // |
| |
| // ** IN_PORTS ** |
| |
| // Trigger Queue |
| in_port(triggerQueue_in, TriggerMsg, triggerQueue, rank=8) { |
| if (triggerQueue_in.isReady(clockEdge())) { |
| peek(triggerQueue_in, TriggerMsg) { |
| TBE tbe := TBEs.lookup(in_msg.addr); |
| assert(is_valid(tbe)); |
| Entry cache_entry := getCacheEntry(in_msg.addr); |
| if ((in_msg.Type == TriggerType:AcksComplete) && (tbe.Upgrade == false)) { |
| trigger(Event:ProbeAcksComplete, in_msg.addr, cache_entry, tbe); |
| } else if ((in_msg.Type == TriggerType:AcksComplete) && (tbe.Upgrade == true)) { |
| trigger(Event:ProbeAcksCompleteReissue, in_msg.addr, cache_entry, tbe); |
| } |
| } |
| } |
| } |
| |
| // Unblock Networks (TCCdir can receive unblocks from TCC, TCPs) |
| // Port on first (of three) wire buffers from TCC |
| in_port(w_TCCUnblock_in, UnblockMsg, w_TCCUnblockToTCCDir, rank=7) { |
| if (w_TCCUnblock_in.isReady(clockEdge())) { |
| peek(w_TCCUnblock_in, UnblockMsg) { |
| TBE tbe := TBEs.lookup(in_msg.addr); |
| Entry cache_entry := getCacheEntry(in_msg.addr); |
| if (in_msg.currentOwner) { |
| trigger(Event:TCCUnblock, in_msg.addr, cache_entry, tbe); |
| } else if (in_msg.valid) { |
| trigger(Event:TCCUnblock_Sharer, in_msg.addr, cache_entry, tbe); |
| } else { |
| trigger(Event:TCCUnblock_NotValid, in_msg.addr, cache_entry, tbe); |
| } |
| } |
| } |
| } |
| |
| in_port(unblockNetwork_in, UnblockMsg, unblockFromTCP, rank=6) { |
| if (unblockNetwork_in.isReady(clockEdge())) { |
| peek(unblockNetwork_in, UnblockMsg) { |
| TBE tbe := TBEs.lookup(in_msg.addr); |
| Entry cache_entry := getCacheEntry(in_msg.addr); |
| if(cache_entry.WaitingUnblocks == 1) { |
| trigger(Event:LastCoreUnblock, in_msg.addr, cache_entry, tbe); |
| } |
| else { |
| trigger(Event:CoreUnblock, in_msg.addr, cache_entry, tbe); |
| } |
| } |
| } |
| } |
| |
| |
| //Responses from TCC, and Cores |
| // Port on second (of three) wire buffers from TCC |
| in_port(w_TCCResponse_in, ResponseMsg, w_respToTCCDir, rank=5) { |
| if (w_TCCResponse_in.isReady(clockEdge())) { |
| peek(w_TCCResponse_in, ResponseMsg) { |
| TBE tbe := TBEs.lookup(in_msg.addr); |
| Entry cache_entry := getCacheEntry(in_msg.addr); |
| if (in_msg.Type == CoherenceResponseType:CPUPrbResp) { |
| trigger(Event:TCCPrbResp, in_msg.addr, cache_entry, tbe); |
| } |
| } |
| } |
| } |
| |
| in_port(responseNetwork_in, ResponseMsg, responseFromTCP, rank=4) { |
| if (responseNetwork_in.isReady(clockEdge())) { |
| peek(responseNetwork_in, ResponseMsg) { |
| TBE tbe := TBEs.lookup(in_msg.addr); |
| Entry cache_entry := getCacheEntry(in_msg.addr); |
| if (in_msg.Type == CoherenceResponseType:CPUPrbResp) { |
| trigger(Event:CPUPrbResp, in_msg.addr, cache_entry, tbe); |
| } |
| } |
| } |
| } |
| |
| |
| // Port on third (of three) wire buffers from TCC |
| in_port(w_TCCRequest_in, CPURequestMsg, w_reqToTCCDir, rank=3) { |
| if(w_TCCRequest_in.isReady(clockEdge())) { |
| peek(w_TCCRequest_in, CPURequestMsg) { |
| TBE tbe := TBEs.lookup(in_msg.addr); |
| Entry cache_entry := getCacheEntry(in_msg.addr); |
| if (in_msg.Type == CoherenceRequestType:WrCancel) { |
| trigger(Event:CancelWB, in_msg.addr, cache_entry, tbe); |
| } else if (in_msg.Type == CoherenceRequestType:VicDirty) { |
| if (is_valid(cache_entry) && cache_entry.Owner.isElement(in_msg.Requestor)) { |
| // if modified, or owner with no other sharers |
| if ((cache_entry.CacheState == State:M) || (cache_entry.Sharers.count() == 0)) { |
| assert(cache_entry.Owner.count()==1); |
| trigger(Event:VicDirtyLast, in_msg.addr, cache_entry, tbe); |
| } else { |
| trigger(Event:VicDirty, in_msg.addr, cache_entry, tbe); |
| } |
| } else { |
| trigger(Event:StaleVic, in_msg.addr, cache_entry, tbe); |
| } |
| } else { |
| if (in_msg.Type == CoherenceRequestType:VicClean) { |
| if (is_valid(cache_entry) && cache_entry.Sharers.isElement(in_msg.Requestor)) { |
| if (cache_entry.Sharers.count() == 1) { |
| // Last copy, victimize to L3 |
| trigger(Event:VicClean, in_msg.addr, cache_entry, tbe); |
| } else { |
| // Either not the last copy or stall. No need to victimmize |
| // remove sharer from sharer list |
| assert(cache_entry.Sharers.count() > 1); |
| trigger(Event:NoVic, in_msg.addr, cache_entry, tbe); |
| } |
| } else { |
| trigger(Event:StaleVic, in_msg.addr, cache_entry, tbe); |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| in_port(responseFromNB_in, ResponseMsg, responseFromNB, rank=2) { |
| if (responseFromNB_in.isReady(clockEdge())) { |
| peek(responseFromNB_in, ResponseMsg, block_on="addr") { |
| |
| TBE tbe := TBEs.lookup(in_msg.addr); |
| Entry cache_entry := getCacheEntry(in_msg.addr); |
| if (in_msg.Type == CoherenceResponseType:NBSysResp) { |
| if (in_msg.State == CoherenceState:Modified) { |
| if (in_msg.CtoD) { |
| trigger(Event:NB_AckCtoD, in_msg.addr, cache_entry, tbe); |
| } else { |
| trigger(Event:NB_AckM, in_msg.addr, cache_entry, tbe); |
| } |
| } else if (in_msg.State == CoherenceState:Shared) { |
| trigger(Event:NB_AckS, in_msg.addr, cache_entry, tbe); |
| } else if (in_msg.State == CoherenceState:Exclusive) { |
| trigger(Event:NB_AckE, in_msg.addr, cache_entry, tbe); |
| } |
| } else if (in_msg.Type == CoherenceResponseType:NBSysWBAck) { |
| trigger(Event:NB_AckWB, in_msg.addr, cache_entry, tbe); |
| } else { |
| error("Unexpected Response Message to Core"); |
| } |
| } |
| } |
| } |
| |
| // Finally handling incoming requests (from TCP) and probes (from NB). |
| |
| in_port(probeNetwork_in, NBProbeRequestMsg, probeFromNB, rank=1) { |
| if (probeNetwork_in.isReady(clockEdge())) { |
| peek(probeNetwork_in, NBProbeRequestMsg) { |
| DPRINTF(RubySlicc, "%s\n", in_msg); |
| DPRINTF(RubySlicc, "machineID: %s\n", machineID); |
| Entry cache_entry := getCacheEntry(in_msg.addr); |
| TBE tbe := TBEs.lookup(in_msg.addr); |
| |
| if (in_msg.Type == ProbeRequestType:PrbInv) { |
| if (in_msg.ReturnData) { |
| trigger(Event:PrbInvData, in_msg.addr, cache_entry, tbe); |
| } else { |
| trigger(Event:PrbInv, in_msg.addr, cache_entry, tbe); |
| } |
| } else if (in_msg.Type == ProbeRequestType:PrbDowngrade) { |
| assert(in_msg.ReturnData); |
| trigger(Event:PrbShrData, in_msg.addr, cache_entry, tbe); |
| } |
| } |
| } |
| } |
| |
| |
| in_port(coreRequestNetwork_in, CPURequestMsg, requestFromTCP, rank=0) { |
| if (coreRequestNetwork_in.isReady(clockEdge())) { |
| peek(coreRequestNetwork_in, CPURequestMsg) { |
| TBE tbe := TBEs.lookup(in_msg.addr); |
| Entry cache_entry := getCacheEntry(in_msg.addr); |
| if (presentOrAvail(in_msg.addr)) { |
| if (in_msg.Type == CoherenceRequestType:VicDirty) { |
| trigger(Event:CPUWrite, in_msg.addr, cache_entry, tbe); |
| } else if (in_msg.Type == CoherenceRequestType:VicClean) { |
| if (is_valid(cache_entry) && cache_entry.Owner.isElement(in_msg.Requestor)) { |
| trigger(Event:CPUWrite, in_msg.addr, cache_entry, tbe); |
| } else if(is_valid(cache_entry) && (cache_entry.Sharers.count() + cache_entry.Owner.count() ) >1) { |
| trigger(Event:NoCPUWrite, in_msg.addr, cache_entry, tbe); |
| } else { |
| trigger(Event:CPUWrite, in_msg.addr, cache_entry, tbe); |
| } |
| } else if (in_msg.Type == CoherenceRequestType:RdBlk) { |
| trigger(Event:RdBlk, in_msg.addr, cache_entry, tbe); |
| } else if (in_msg.Type == CoherenceRequestType:RdBlkS) { |
| trigger(Event:RdBlkS, in_msg.addr, cache_entry, tbe); |
| } else if (in_msg.Type == CoherenceRequestType:RdBlkM) { |
| trigger(Event:RdBlkM, in_msg.addr, cache_entry, tbe); |
| } else if (in_msg.Type == CoherenceRequestType:WrCancel) { |
| trigger(Event:CPUWriteCancel, in_msg.addr, cache_entry, tbe); |
| } |
| } else { |
| // All requests require a directory entry |
| Addr victim := directory.cacheProbe(in_msg.addr); |
| trigger(Event:Recall, victim, getCacheEntry(victim), TBEs.lookup(victim)); |
| } |
| } |
| } |
| } |
| |
| |
| |
| |
| // Actions |
| |
| //Downward facing actions |
| |
| action(c_clearOwner, "c", desc="Clear the owner field") { |
| cache_entry.Owner.clear(); |
| } |
| |
| action(rS_removeRequesterFromSharers, "rS", desc="Remove unblocker from sharer list") { |
| peek(unblockNetwork_in, UnblockMsg) { |
| cache_entry.Sharers.remove(in_msg.Sender); |
| } |
| } |
| |
| action(rT_removeTCCFromSharers, "rT", desc="Remove TCC from sharer list") { |
| peek(w_TCCRequest_in, CPURequestMsg) { |
| cache_entry.Sharers.remove(in_msg.Requestor); |
| } |
| } |
| |
| action(rO_removeOriginalRequestorFromSharers, "rO", desc="Remove replacing core from sharer list") { |
| peek(coreRequestNetwork_in, CPURequestMsg) { |
| cache_entry.Sharers.remove(in_msg.Requestor); |
| } |
| } |
| |
| action(rC_removeCoreFromSharers, "rC", desc="Remove replacing core from sharer list") { |
| peek(coreRequestNetwork_in, CPURequestMsg) { |
| cache_entry.Sharers.remove(in_msg.Requestor); |
| } |
| } |
| |
| action(rCo_removeCoreFromOwner, "rCo", desc="Remove replacing core from sharer list") { |
| // Note that under some cases this action will try to remove a stale owner |
| peek(coreRequestNetwork_in, CPURequestMsg) { |
| cache_entry.Owner.remove(in_msg.Requestor); |
| } |
| } |
| |
| action(rR_removeResponderFromSharers, "rR", desc="Remove responder from sharer list") { |
| peek(responseNetwork_in, ResponseMsg) { |
| cache_entry.Sharers.remove(in_msg.Sender); |
| } |
| } |
| |
| action(nC_sendNullWBAckToCore, "nC", desc = "send a null WB Ack to release core") { |
| peek(coreRequestNetwork_in, CPURequestMsg) { |
| enqueue(responseToCore_out, ResponseMsg, 1) { |
| out_msg.addr := address; |
| out_msg.Type := CoherenceResponseType:TDSysWBNack; |
| out_msg.Sender := machineID; |
| out_msg.Destination.add(in_msg.Requestor); |
| out_msg.MessageSize := in_msg.MessageSize; |
| } |
| } |
| } |
| |
| action(nT_sendNullWBAckToTCC, "nT", desc = "send a null WB Ack to release TCC") { |
| peek(w_TCCRequest_in, CPURequestMsg) { |
| enqueue(w_respTCC_out, ResponseMsg, 1) { |
| out_msg.addr := address; |
| out_msg.Type := CoherenceResponseType:TDSysWBAck; |
| out_msg.Sender := machineID; |
| out_msg.Destination.add(in_msg.Requestor); |
| out_msg.MessageSize := in_msg.MessageSize; |
| } |
| } |
| } |
| |
| action(eto_moveExSharerToOwner, "eto", desc="move the current exclusive sharer to owner") { |
| assert(cache_entry.Sharers.count() == 1); |
| assert(cache_entry.Owner.count() == 0); |
| cache_entry.Owner := cache_entry.Sharers; |
| cache_entry.Sharers.clear(); |
| APPEND_TRANSITION_COMMENT(" new owner "); |
| APPEND_TRANSITION_COMMENT(cache_entry.Owner); |
| } |
| |
| action(aT_addTCCToSharers, "aT", desc="Add TCC to sharer list") { |
| peek(w_TCCUnblock_in, UnblockMsg) { |
| cache_entry.Sharers.add(in_msg.Sender); |
| } |
| } |
| |
| action(as_addToSharers, "as", desc="Add unblocker to sharer list") { |
| peek(unblockNetwork_in, UnblockMsg) { |
| cache_entry.Sharers.add(in_msg.Sender); |
| } |
| } |
| |
| action(c_moveOwnerToSharer, "cc", desc="Move owner to sharers") { |
| cache_entry.Sharers.addNetDest(cache_entry.Owner); |
| cache_entry.Owner.clear(); |
| } |
| |
| action(cc_clearSharers, "\c", desc="Clear the sharers field") { |
| cache_entry.Sharers.clear(); |
| } |
| |
| action(e_ownerIsUnblocker, "e", desc="The owner is now the unblocker") { |
| peek(unblockNetwork_in, UnblockMsg) { |
| cache_entry.Owner.clear(); |
| cache_entry.Owner.add(in_msg.Sender); |
| APPEND_TRANSITION_COMMENT(" tcp_ub owner "); |
| APPEND_TRANSITION_COMMENT(cache_entry.Owner); |
| } |
| } |
| |
| action(eT_ownerIsUnblocker, "eT", desc="TCC (unblocker) is now owner") { |
| peek(w_TCCUnblock_in, UnblockMsg) { |
| cache_entry.Owner.clear(); |
| cache_entry.Owner.add(in_msg.Sender); |
| APPEND_TRANSITION_COMMENT(" tcc_ub owner "); |
| APPEND_TRANSITION_COMMENT(cache_entry.Owner); |
| } |
| } |
| |
| action(ctr_copyTCCResponseToTBE, "ctr", desc="Copy TCC probe response data to TBE") { |
| peek(w_TCCResponse_in, ResponseMsg) { |
| // Overwrite data if tbe does not hold dirty data. Stop once it is dirty. |
| if(tbe.Dirty == false) { |
| tbe.DataBlk := in_msg.DataBlk; |
| tbe.Dirty := in_msg.Dirty; |
| tbe.Sender := in_msg.Sender; |
| } |
| DPRINTF(RubySlicc, "%s\n", (tbe.DataBlk)); |
| } |
| } |
| |
| action(ccr_copyCoreResponseToTBE, "ccr", desc="Copy core probe response data to TBE") { |
| peek(responseNetwork_in, ResponseMsg) { |
| // Overwrite data if tbe does not hold dirty data. Stop once it is dirty. |
| if(tbe.Dirty == false) { |
| tbe.DataBlk := in_msg.DataBlk; |
| tbe.Dirty := in_msg.Dirty; |
| |
| if(tbe.Sender == machineID) { |
| tbe.Sender := in_msg.Sender; |
| } |
| } |
| DPRINTF(RubySlicc, "%s\n", (tbe.DataBlk)); |
| } |
| } |
| |
| action(cd_clearDirtyBitTBE, "cd", desc="Clear Dirty bit in TBE") { |
| tbe.Dirty := false; |
| } |
| |
| action(n_issueRdBlk, "n-", desc="Issue RdBlk") { |
| enqueue(requestToNB_out, CPURequestMsg, issue_latency) { |
| out_msg.addr := address; |
| out_msg.Type := CoherenceRequestType:RdBlk; |
| out_msg.Requestor := machineID; |
| out_msg.Destination.add(map_Address_to_Directory(address)); |
| out_msg.MessageSize := MessageSizeType:Request_Control; |
| } |
| } |
| |
| action(nS_issueRdBlkS, "nS", desc="Issue RdBlkS") { |
| enqueue(requestToNB_out, CPURequestMsg, issue_latency) { |
| out_msg.addr := address; |
| out_msg.Type := CoherenceRequestType:RdBlkS; |
| out_msg.Requestor := machineID; |
| out_msg.Destination.add(map_Address_to_Directory(address)); |
| out_msg.MessageSize := MessageSizeType:Request_Control; |
| } |
| } |
| |
| action(nM_issueRdBlkM, "nM", desc="Issue RdBlkM") { |
| enqueue(requestToNB_out, CPURequestMsg, issue_latency) { |
| out_msg.addr := address; |
| out_msg.Type := CoherenceRequestType:RdBlkM; |
| out_msg.Requestor := machineID; |
| out_msg.Destination.add(map_Address_to_Directory(address)); |
| out_msg.MessageSize := MessageSizeType:Request_Control; |
| } |
| } |
| |
| action(rU_rememberUpgrade, "rU", desc="Remember that this was an upgrade") { |
| tbe.Upgrade := true; |
| } |
| |
| action(ruo_rememberUntransferredOwner, "ruo", desc="Remember the untransferred owner") { |
| peek(responseNetwork_in, ResponseMsg) { |
| if(in_msg.UntransferredOwner == true) { |
| tbe.UntransferredOwner := in_msg.Sender; |
| tbe.UntransferredOwnerExists := true; |
| } |
| DPRINTF(RubySlicc, "%s\n", (in_msg)); |
| } |
| } |
| |
| action(ruoT_rememberUntransferredOwnerTCC, "ruoT", desc="Remember the untransferred owner") { |
| peek(w_TCCResponse_in, ResponseMsg) { |
| if(in_msg.UntransferredOwner == true) { |
| tbe.UntransferredOwner := in_msg.Sender; |
| tbe.UntransferredOwnerExists := true; |
| } |
| DPRINTF(RubySlicc, "%s\n", (in_msg)); |
| } |
| } |
| |
| action(vd_victim, "vd", desc="Victimize M/O Data") { |
| enqueue(requestToNB_out, CPURequestMsg, issue_latency) { |
| out_msg.addr := address; |
| out_msg.Requestor := machineID; |
| out_msg.Destination.add(map_Address_to_Directory(address)); |
| out_msg.MessageSize := MessageSizeType:Request_Control; |
| out_msg.Type := CoherenceRequestType:VicDirty; |
| if (cache_entry.CacheState == State:O) { |
| out_msg.Shared := true; |
| } else { |
| out_msg.Shared := false; |
| } |
| out_msg.Dirty := true; |
| } |
| } |
| |
| action(vc_victim, "vc", desc="Victimize E/S Data") { |
| enqueue(requestToNB_out, CPURequestMsg, issue_latency) { |
| out_msg.addr := address; |
| out_msg.Requestor := machineID; |
| out_msg.Destination.add(map_Address_to_Directory(address)); |
| out_msg.MessageSize := MessageSizeType:Request_Control; |
| out_msg.Type := CoherenceRequestType:VicClean; |
| if (cache_entry.CacheState == State:S) { |
| out_msg.Shared := true; |
| } else { |
| out_msg.Shared := false; |
| } |
| out_msg.Dirty := false; |
| } |
| } |
| |
| |
| action(sT_sendRequestToTCC, "sT", desc="send request to TCC") { |
| peek(coreRequestNetwork_in, CPURequestMsg) { |
| enqueue(w_requestTCC_out, CPURequestMsg, 1) { |
| out_msg.addr := address; |
| out_msg.Type := in_msg.Type; |
| out_msg.Requestor := in_msg.Requestor; |
| out_msg.DataBlk := in_msg.DataBlk; |
| out_msg.Destination.add(mapAddressToRange(address,MachineType:TCC, |
| TCC_select_low_bit, TCC_select_num_bits)); |
| out_msg.Shared := in_msg.Shared; |
| out_msg.MessageSize := in_msg.MessageSize; |
| } |
| APPEND_TRANSITION_COMMENT(" requestor "); |
| APPEND_TRANSITION_COMMENT(in_msg.Requestor); |
| |
| } |
| } |
| |
| |
| action(sc_probeShrCoreData, "sc", desc="probe shared cores, return data") { |
| MachineID tcc := mapAddressToRange(address,MachineType:TCC, |
| TCC_select_low_bit, TCC_select_num_bits); |
| |
| temp := cache_entry.Sharers; |
| temp.addNetDest(cache_entry.Owner); |
| if (temp.isElement(tcc)) { |
| temp.remove(tcc); |
| } |
| if (temp.count() > 0) { |
| enqueue(probeToCore_out, TDProbeRequestMsg, response_latency) { |
| out_msg.addr := address; |
| out_msg.Type := ProbeRequestType:PrbDowngrade; |
| out_msg.ReturnData := true; |
| out_msg.MessageSize := MessageSizeType:Control; |
| out_msg.Destination := temp; |
| tbe.NumPendingAcks := temp.count(); |
| if(cache_entry.CacheState == State:M) { |
| assert(tbe.NumPendingAcks == 1); |
| } |
| DPRINTF(RubySlicc, "%s\n", (out_msg)); |
| } |
| } |
| } |
| |
| action(ls2_probeShrL2Data, "ls2", desc="local probe downgrade L2, return data") { |
| MachineID tcc := mapAddressToRange(address,MachineType:TCC, |
| TCC_select_low_bit, TCC_select_num_bits); |
| if ((cache_entry.Sharers.isElement(tcc)) || (cache_entry.Owner.isElement(tcc))) { |
| enqueue(w_probeTCC_out, TDProbeRequestMsg, 1) { |
| out_msg.addr := address; |
| out_msg.Type := ProbeRequestType:PrbDowngrade; |
| out_msg.ReturnData := true; |
| out_msg.MessageSize := MessageSizeType:Control; |
| out_msg.Destination.add(tcc); |
| tbe.NumPendingAcks := tbe.NumPendingAcks + 1; |
| DPRINTF(RubySlicc, "%s\n", out_msg); |
| |
| } |
| } |
| } |
| |
| action(s2_probeShrL2Data, "s2", desc="probe shared L2, return data") { |
| MachineID tcc := mapAddressToRange(address,MachineType:TCC, |
| TCC_select_low_bit, TCC_select_num_bits); |
| if ((cache_entry.Sharers.isElement(tcc)) || (cache_entry.Owner.isElement(tcc))) { |
| enqueue(w_probeTCC_out, TDProbeRequestMsg, 1) { |
| out_msg.addr := address; |
| out_msg.Type := ProbeRequestType:PrbDowngrade; |
| out_msg.ReturnData := true; |
| out_msg.MessageSize := MessageSizeType:Control; |
| out_msg.Destination.add(tcc); |
| tbe.NumPendingAcks := tbe.NumPendingAcks + 1; |
| DPRINTF(RubySlicc, "%s\n", out_msg); |
| |
| } |
| } |
| } |
| |
| action(ldc_probeInvCoreData, "ldc", desc="local probe to inv cores, return data") { |
| MachineID tcc := mapAddressToRange(address,MachineType:TCC, |
| TCC_select_low_bit, TCC_select_num_bits); |
| peek(coreRequestNetwork_in, CPURequestMsg) { |
| NetDest dest:= cache_entry.Sharers; |
| dest.addNetDest(cache_entry.Owner); |
| if(dest.isElement(tcc)){ |
| dest.remove(tcc); |
| } |
| dest.remove(in_msg.Requestor); |
| tbe.NumPendingAcks := dest.count(); |
| if (dest.count()>0){ |
| enqueue(probeToCore_out, TDProbeRequestMsg, response_latency) { |
| out_msg.addr := address; |
| out_msg.Type := ProbeRequestType:PrbInv; |
| out_msg.ReturnData := true; |
| out_msg.MessageSize := MessageSizeType:Control; |
| |
| out_msg.Destination.addNetDest(dest); |
| if(cache_entry.CacheState == State:M) { |
| assert(tbe.NumPendingAcks == 1); |
| } |
| |
| DPRINTF(RubySlicc, "%s\n", (out_msg)); |
| } |
| } |
| } |
| } |
| |
| action(ld2_probeInvL2Data, "ld2", desc="local probe inv L2, return data") { |
| MachineID tcc := mapAddressToRange(address,MachineType:TCC, |
| TCC_select_low_bit, TCC_select_num_bits); |
| if ((cache_entry.Sharers.isElement(tcc)) || (cache_entry.Owner.isElement(tcc))) { |
| enqueue(w_probeTCC_out, TDProbeRequestMsg, 1) { |
| out_msg.addr := address; |
| out_msg.Type := ProbeRequestType:PrbInv; |
| out_msg.ReturnData := true; |
| out_msg.MessageSize := MessageSizeType:Control; |
| out_msg.Destination.add(tcc); |
| tbe.NumPendingAcks := tbe.NumPendingAcks + 1; |
| DPRINTF(RubySlicc, "%s\n", out_msg); |
| |
| } |
| } |
| } |
| |
| action(dc_probeInvCoreData, "dc", desc="probe inv cores + TCC, return data") { |
| MachineID tcc := mapAddressToRange(address,MachineType:TCC, |
| TCC_select_low_bit, TCC_select_num_bits); |
| enqueue(probeToCore_out, TDProbeRequestMsg, response_latency) { |
| out_msg.addr := address; |
| out_msg.Type := ProbeRequestType:PrbInv; |
| out_msg.ReturnData := true; |
| out_msg.MessageSize := MessageSizeType:Control; |
| |
| out_msg.Destination.addNetDest(cache_entry.Sharers); |
| out_msg.Destination.addNetDest(cache_entry.Owner); |
| tbe.NumPendingAcks := cache_entry.Sharers.count() + cache_entry.Owner.count(); |
| if(cache_entry.CacheState == State:M) { |
| assert(tbe.NumPendingAcks == 1); |
| } |
| if (out_msg.Destination.isElement(tcc)) { |
| out_msg.Destination.remove(tcc); |
| tbe.NumPendingAcks := tbe.NumPendingAcks - 1; |
| } |
| |
| DPRINTF(RubySlicc, "%s\n", (out_msg)); |
| } |
| } |
| |
| action(d2_probeInvL2Data, "d2", desc="probe inv L2, return data") { |
| MachineID tcc := mapAddressToRange(address,MachineType:TCC, |
| TCC_select_low_bit, TCC_select_num_bits); |
| if ((cache_entry.Sharers.isElement(tcc)) || (cache_entry.Owner.isElement(tcc))) { |
| enqueue(w_probeTCC_out, TDProbeRequestMsg, 1) { |
| out_msg.addr := address; |
| out_msg.Type := ProbeRequestType:PrbInv; |
| out_msg.ReturnData := true; |
| out_msg.MessageSize := MessageSizeType:Control; |
| out_msg.Destination.add(tcc); |
| tbe.NumPendingAcks := tbe.NumPendingAcks + 1; |
| DPRINTF(RubySlicc, "%s\n", out_msg); |
| |
| } |
| } |
| } |
| |
| action(lpc_probeInvCore, "lpc", desc="local probe inv cores, no data") { |
| peek(coreRequestNetwork_in, CPURequestMsg) { |
| TCC_dir_subtree.broadcast(MachineType:TCP); |
| TCC_dir_subtree.broadcast(MachineType:SQC); |
| |
| temp := cache_entry.Sharers; |
| temp := temp.OR(cache_entry.Owner); |
| TCC_dir_subtree := TCC_dir_subtree.AND(temp); |
| tbe.NumPendingAcks := TCC_dir_subtree.count(); |
| if(cache_entry.CacheState == State:M) { |
| assert(tbe.NumPendingAcks == 1); |
| } |
| if(TCC_dir_subtree.isElement(in_msg.Requestor)) { |
| TCC_dir_subtree.remove(in_msg.Requestor); |
| tbe.NumPendingAcks := tbe.NumPendingAcks - 1; |
| } |
| |
| if(TCC_dir_subtree.count() > 0) { |
| enqueue(probeToCore_out, TDProbeRequestMsg, response_latency) { |
| out_msg.addr := address; |
| out_msg.Type := ProbeRequestType:PrbInv; |
| out_msg.ReturnData := false; |
| out_msg.MessageSize := MessageSizeType:Control; |
| out_msg.localCtoD := true; |
| |
| out_msg.Destination.addNetDest(TCC_dir_subtree); |
| |
| DPRINTF(RubySlicc, "%s\n", (out_msg)); |
| } |
| } |
| } |
| } |
| |
| action(ipc_probeInvCore, "ipc", desc="probe inv cores, no data") { |
| TCC_dir_subtree.broadcast(MachineType:TCP); |
| TCC_dir_subtree.broadcast(MachineType:SQC); |
| |
| temp := cache_entry.Sharers; |
| temp := temp.OR(cache_entry.Owner); |
| TCC_dir_subtree := TCC_dir_subtree.AND(temp); |
| tbe.NumPendingAcks := TCC_dir_subtree.count(); |
| if(TCC_dir_subtree.count() > 0) { |
| |
| enqueue(probeToCore_out, TDProbeRequestMsg, response_latency) { |
| out_msg.addr := address; |
| out_msg.Type := ProbeRequestType:PrbInv; |
| out_msg.ReturnData := false; |
| out_msg.MessageSize := MessageSizeType:Control; |
| |
| out_msg.Destination.addNetDest(TCC_dir_subtree); |
| if(cache_entry.CacheState == State:M) { |
| assert(tbe.NumPendingAcks == 1); |
| } |
| |
| DPRINTF(RubySlicc, "%s\n", (out_msg)); |
| } |
| } |
| } |
| |
| action(i2_probeInvL2, "i2", desc="probe inv L2, no data") { |
| MachineID tcc := mapAddressToRange(address,MachineType:TCC, |
| TCC_select_low_bit, TCC_select_num_bits); |
| if ((cache_entry.Sharers.isElement(tcc)) || (cache_entry.Owner.isElement(tcc))) { |
| enqueue(w_probeTCC_out, TDProbeRequestMsg, 1) { |
| tbe.NumPendingAcks := tbe.NumPendingAcks + 1; |
| out_msg.addr := address; |
| out_msg.Type := ProbeRequestType:PrbInv; |
| out_msg.ReturnData := false; |
| out_msg.MessageSize := MessageSizeType:Control; |
| out_msg.Destination.add(tcc); |
| DPRINTF(RubySlicc, "%s\n", out_msg); |
| |
| } |
| } |
| } |
| |
| action(pi_sendProbeResponseInv, "pi", desc="send probe ack inv, no data") { |
| enqueue(responseToNB_out, ResponseMsg, issue_latency) { |
| out_msg.addr := address; |
| out_msg.Type := CoherenceResponseType:CPUPrbResp; // TCC, L3 respond in same way to probes |
| out_msg.Sender := machineID; |
| out_msg.Destination.add(map_Address_to_Directory(address)); |
| out_msg.Dirty := false; |
| out_msg.Hit := false; |
| out_msg.Ntsl := true; |
| out_msg.State := CoherenceState:NA; |
| out_msg.MessageSize := MessageSizeType:Response_Control; |
| } |
| } |
| |
| action(pim_sendProbeResponseInvMs, "pim", desc="send probe ack inv, no data") { |
| enqueue(responseToNB_out, ResponseMsg, issue_latency) { |
| out_msg.addr := address; |
| out_msg.Type := CoherenceResponseType:CPUPrbResp; // L3 and TCC respond in same way to probes |
| out_msg.Sender := machineID; |
| out_msg.Destination.add(map_Address_to_Directory(address)); |
| out_msg.Dirty := false; |
| out_msg.Ntsl := true; |
| out_msg.Hit := false; |
| out_msg.State := CoherenceState:NA; |
| out_msg.MessageSize := MessageSizeType:Response_Control; |
| } |
| } |
| |
| action(prm_sendProbeResponseMiss, "prm", desc="send probe ack PrbShrData, no data") { |
| enqueue(responseToNB_out, ResponseMsg, issue_latency) { |
| out_msg.addr := address; |
| out_msg.Type := CoherenceResponseType:CPUPrbResp; // L3 and TCC respond in same way to probes |
| out_msg.Sender := machineID; |
| out_msg.Destination.add(map_Address_to_Directory(address)); |
| out_msg.Dirty := false; // only true if sending back data i think |
| out_msg.Hit := false; |
| out_msg.Ntsl := false; |
| out_msg.State := CoherenceState:NA; |
| out_msg.MessageSize := MessageSizeType:Response_Control; |
| } |
| } |
| |
| |
| |
| action(pd_sendProbeResponseData, "pd", desc="send probe ack, with data") { |
| enqueue(responseToNB_out, ResponseMsg, issue_latency) { |
| assert(is_valid(cache_entry) || is_valid(tbe)); |
| out_msg.addr := address; |
| out_msg.Type := CoherenceResponseType:CPUPrbResp; |
| out_msg.Sender := machineID; |
| out_msg.Destination.add(map_Address_to_Directory(address)); |
| out_msg.DataBlk := getDataBlock(address); |
| if (is_valid(tbe)) { |
| out_msg.Dirty := tbe.Dirty; |
| } |
| out_msg.Hit := true; |
| out_msg.State := CoherenceState:NA; |
| out_msg.MessageSize := MessageSizeType:Response_Data; |
| } |
| } |
| |
| |
| action(pdm_sendProbeResponseDataMs, "pdm", desc="send probe ack, with data") { |
| enqueue(responseToNB_out, ResponseMsg, issue_latency) { |
| assert(is_valid(cache_entry) || is_valid(tbe)); |
| assert(is_valid(cache_entry)); |
| out_msg.addr := address; |
| out_msg.Type := CoherenceResponseType:CPUPrbResp; |
| out_msg.Sender := machineID; |
| out_msg.Destination.add(map_Address_to_Directory(address)); |
| out_msg.DataBlk := getDataBlock(address); |
| if (is_valid(tbe)) { |
| out_msg.Dirty := tbe.Dirty; |
| } |
| out_msg.Hit := true; |
| out_msg.State := CoherenceState:NA; |
| out_msg.MessageSize := MessageSizeType:Response_Data; |
| } |
| } |
| |
| action(mc_cancelWB, "mc", desc="send writeback cancel to NB directory") { |
| enqueue(requestToNB_out, CPURequestMsg, issue_latency) { |
| out_msg.addr := address; |
| out_msg.Type := CoherenceRequestType:WrCancel; |
| out_msg.Destination.add(map_Address_to_Directory(address)); |
| out_msg.Requestor := machineID; |
| out_msg.MessageSize := MessageSizeType:Request_Control; |
| } |
| } |
| |
| action(sCS_sendCollectiveResponseS, "sCS", desc="send shared response to all merged TCP/SQC") { |
| enqueue(responseToCore_out, ResponseMsg, 1) { |
| out_msg.addr := address; |
| out_msg.Type := CoherenceResponseType:TDSysResp; |
| out_msg.Sender := tbe.Sender; |
| out_msg.DataBlk := tbe.DataBlk; |
| out_msg.MessageSize := MessageSizeType:Response_Data; |
| out_msg.CtoD := false; |
| out_msg.State := CoherenceState:Shared; |
| out_msg.Destination.addNetDest(cache_entry.MergedSharers); |
| out_msg.Shared := tbe.Shared; |
| out_msg.Dirty := tbe.Dirty; |
| DPRINTF(RubySlicc, "%s\n", out_msg); |
| } |
| } |
| |
| action(sS_sendResponseS, "sS", desc="send shared response to TCP/SQC") { |
| enqueue(responseToCore_out, ResponseMsg, 1) { |
| out_msg.addr := address; |
| out_msg.Type := CoherenceResponseType:TDSysResp; |
| out_msg.Sender := tbe.Sender; |
| out_msg.DataBlk := tbe.DataBlk; |
| out_msg.MessageSize := MessageSizeType:Response_Data; |
| out_msg.CtoD := false; |
| out_msg.State := CoherenceState:Shared; |
| out_msg.Destination.add(tbe.OriginalRequestor); |
| out_msg.Shared := tbe.Shared; |
| out_msg.Dirty := tbe.Dirty; |
| DPRINTF(RubySlicc, "%s\n", out_msg); |
| } |
| } |
| |
| action(sM_sendResponseM, "sM", desc="send response to TCP/SQC") { |
| enqueue(responseToCore_out, ResponseMsg, 1) { |
| out_msg.addr := address; |
| out_msg.Type := CoherenceResponseType:TDSysResp; |
| out_msg.Sender := tbe.Sender; |
| out_msg.DataBlk := tbe.DataBlk; |
| out_msg.MessageSize := MessageSizeType:Response_Data; |
| out_msg.CtoD := false; |
| out_msg.State := CoherenceState:Modified; |
| out_msg.Destination.add(tbe.OriginalRequestor); |
| out_msg.Shared := tbe.Shared; |
| out_msg.Dirty := tbe.Dirty; |
| DPRINTF(RubySlicc, "%s\n", out_msg); |
| } |
| } |
| |
| |
| |
| action(fw2_forwardWBAck, "fw2", desc="forward WBAck to TCC") { |
| peek(responseFromNB_in, ResponseMsg) { |
| if(tbe.OriginalRequestor != machineID) { |
| enqueue(w_respTCC_out, ResponseMsg, 1) { |
| out_msg.addr := address; |
| out_msg.Type := CoherenceResponseType:TDSysWBAck; |
| out_msg.Sender := machineID; |
| //out_msg.DataBlk := tbe.DataBlk; |
| out_msg.Destination.add(tbe.OriginalRequestor); |
| out_msg.MessageSize := in_msg.MessageSize; |
| } |
| } |
| } |
| } |
| |
| action(sa_saveSysAck, "sa", desc="Save SysAck ") { |
| peek(responseFromNB_in, ResponseMsg) { |
| tbe.Dirty := in_msg.Dirty; |
| if (tbe.Dirty == false) { |
| tbe.DataBlk := in_msg.DataBlk; |
| } |
| else { |
| tbe.DataBlk := tbe.DataBlk; |
| } |
| tbe.CtoD := in_msg.CtoD; |
| tbe.CohState := in_msg.State; |
| tbe.Shared := in_msg.Shared; |
| tbe.MessageSize := in_msg.MessageSize; |
| } |
| } |
| |
| action(fsa_forwardSavedAck, "fsa", desc="forward saved SysAck to TCP or SQC") { |
| enqueue(responseToCore_out, ResponseMsg, 1) { |
| out_msg.addr := address; |
| out_msg.Type := CoherenceResponseType:TDSysResp; |
| out_msg.Sender := machineID; |
| if (tbe.Dirty == false) { |
| out_msg.DataBlk := tbe.DataBlk; |
| } |
| else { |
| out_msg.DataBlk := tbe.DataBlk; |
| } |
| out_msg.CtoD := tbe.CtoD; |
| out_msg.State := tbe.CohState; |
| out_msg.Destination.add(tbe.OriginalRequestor); |
| out_msg.Shared := tbe.Shared; |
| out_msg.MessageSize := tbe.MessageSize; |
| out_msg.Dirty := tbe.Dirty; |
| out_msg.Sender := tbe.Sender; |
| } |
| } |
| |
| action(fa_forwardSysAck, "fa", desc="forward SysAck to TCP or SQC") { |
| peek(responseFromNB_in, ResponseMsg) { |
| enqueue(responseToCore_out, ResponseMsg, 1) { |
| out_msg.addr := address; |
| out_msg.Type := CoherenceResponseType:TDSysResp; |
| out_msg.Sender := machineID; |
| if (tbe.Dirty == false) { |
| out_msg.DataBlk := in_msg.DataBlk; |
| tbe.Sender := machineID; |
| } |
| else { |
| out_msg.DataBlk := tbe.DataBlk; |
| } |
| out_msg.CtoD := in_msg.CtoD; |
| out_msg.State := in_msg.State; |
| out_msg.Destination.add(tbe.OriginalRequestor); |
| out_msg.Shared := in_msg.Shared; |
| out_msg.MessageSize := in_msg.MessageSize; |
| out_msg.Dirty := in_msg.Dirty; |
| out_msg.Sender := tbe.Sender; |
| DPRINTF(RubySlicc, "%s\n", (out_msg.DataBlk)); |
| } |
| } |
| } |
| |
| action(pso_probeSharedDataOwner, "pso", desc="probe shared data at owner") { |
| MachineID tcc := mapAddressToRange(address,MachineType:TCC, |
| TCC_select_low_bit, TCC_select_num_bits); |
| if (cache_entry.Owner.isElement(tcc)) { |
| enqueue(w_probeTCC_out, TDProbeRequestMsg, 1) { |
| out_msg.addr := address; |
| out_msg.Type := ProbeRequestType:PrbDowngrade; |
| out_msg.ReturnData := true; |
| out_msg.MessageSize := MessageSizeType:Control; |
| out_msg.Destination.add(tcc); |
| DPRINTF(RubySlicc, "%s\n", out_msg); |
| } |
| } |
| else { // i.e., owner is a core |
| enqueue(probeToCore_out, TDProbeRequestMsg, response_latency) { |
| out_msg.addr := address; |
| out_msg.Type := ProbeRequestType:PrbDowngrade; |
| out_msg.ReturnData := true; |
| out_msg.MessageSize := MessageSizeType:Control; |
| out_msg.Destination.addNetDest(cache_entry.Owner); |
| DPRINTF(RubySlicc, "%s\n", out_msg); |
| } |
| } |
| tbe.NumPendingAcks := 1; |
| } |
| |
| action(i_popIncomingRequestQueue, "i", desc="Pop incoming request queue") { |
| coreRequestNetwork_in.dequeue(clockEdge()); |
| } |
| |
| action(j_popIncomingUnblockQueue, "j", desc="Pop incoming unblock queue") { |
| unblockNetwork_in.dequeue(clockEdge()); |
| } |
| |
| action(pk_popResponseQueue, "pk", desc="Pop response queue") { |
| responseNetwork_in.dequeue(clockEdge()); |
| } |
| |
| action(pp_popProbeQueue, "pp", desc="Pop incoming probe queue") { |
| probeNetwork_in.dequeue(clockEdge()); |
| } |
| |
| action(pR_popResponseFromNBQueue, "pR", desc="Pop incoming Response queue From NB") { |
| responseFromNB_in.dequeue(clockEdge()); |
| } |
| |
| action(pt_popTriggerQueue, "pt", desc="pop trigger queue") { |
| triggerQueue_in.dequeue(clockEdge()); |
| } |
| |
| action(pl_popTCCRequestQueue, "pl", desc="pop TCC request queue") { |
| w_TCCRequest_in.dequeue(clockEdge()); |
| } |
| |
| action(plr_popTCCResponseQueue, "plr", desc="pop TCC response queue") { |
| w_TCCResponse_in.dequeue(clockEdge()); |
| } |
| |
| action(plu_popTCCUnblockQueue, "plu", desc="pop TCC unblock queue") { |
| w_TCCUnblock_in.dequeue(clockEdge()); |
| } |
| |
| |
| action(m_addUnlockerToSharers, "m", desc="Add the unlocker to the sharer list") { |
| peek(unblockNetwork_in, UnblockMsg) { |
| cache_entry.Sharers.add(in_msg.Sender); |
| cache_entry.MergedSharers.remove(in_msg.Sender); |
| assert(cache_entry.WaitingUnblocks >= 0); |
| cache_entry.WaitingUnblocks := cache_entry.WaitingUnblocks - 1; |
| } |
| } |
| |
| action(q_addOutstandingMergedSharer, "q", desc="Increment outstanding requests") { |
| peek(coreRequestNetwork_in, CPURequestMsg) { |
| cache_entry.MergedSharers.add(in_msg.Requestor); |
| cache_entry.WaitingUnblocks := cache_entry.WaitingUnblocks + 1; |
| } |
| } |
| |
| action(uu_sendUnblock, "uu", desc="state changed, unblock") { |
| enqueue(unblockToNB_out, UnblockMsg, issue_latency) { |
| out_msg.addr := address; |
| out_msg.Destination.add(map_Address_to_Directory(address)); |
| out_msg.MessageSize := MessageSizeType:Unblock_Control; |
| DPRINTF(RubySlicc, "%s\n", out_msg); |
| } |
| } |
| |
| action(zz_recycleRequest, "\z", desc="Recycle the request queue") { |
| coreRequestNetwork_in.recycle(clockEdge(), cyclesToTicks(recycle_latency)); |
| } |
| |
| action(yy_recycleTCCRequestQueue, "yy", desc="recycle yy request queue") { |
| w_TCCRequest_in.recycle(clockEdge(), cyclesToTicks(recycle_latency)); |
| } |
| |
| action(xz_recycleResponseQueue, "xz", desc="recycle response queue") { |
| responseNetwork_in.recycle(clockEdge(), cyclesToTicks(recycle_latency)); |
| } |
| |
| action(xx_recycleTCCResponseQueue, "xx", desc="recycle TCC response queue") { |
| w_TCCResponse_in.recycle(clockEdge(), cyclesToTicks(recycle_latency)); |
| } |
| |
| action(vv_recycleTCCUnblockQueue, "vv", desc="Recycle the probe request queue") { |
| w_TCCUnblock_in.recycle(clockEdge(), cyclesToTicks(recycle_latency)); |
| } |
| |
| action(xy_recycleUnblockQueue, "xy", desc="Recycle the probe request queue") { |
| w_TCCUnblock_in.recycle(clockEdge(), cyclesToTicks(recycle_latency)); |
| } |
| |
| action(ww_recycleProbeRequest, "ww", desc="Recycle the probe request queue") { |
| probeNetwork_in.recycle(clockEdge(), cyclesToTicks(recycle_latency)); |
| } |
| |
| action(x_decrementAcks, "x", desc="decrement Acks pending") { |
| tbe.NumPendingAcks := tbe.NumPendingAcks - 1; |
| } |
| |
| action(o_checkForAckCompletion, "o", desc="check for ack completion") { |
| if (tbe.NumPendingAcks == 0) { |
| enqueue(triggerQueue_out, TriggerMsg, 1) { |
| out_msg.addr := address; |
| out_msg.Type := TriggerType:AcksComplete; |
| } |
| } |
| APPEND_TRANSITION_COMMENT(" tbe acks "); |
| APPEND_TRANSITION_COMMENT(tbe.NumPendingAcks); |
| } |
| |
| action(tp_allocateTBE, "tp", desc="allocate TBE Entry for upward transactions") { |
| check_allocate(TBEs); |
| peek(probeNetwork_in, NBProbeRequestMsg) { |
| TBEs.allocate(address); |
| set_tbe(TBEs.lookup(address)); |
| tbe.Dirty := false; |
| tbe.NumPendingAcks := 0; |
| tbe.UntransferredOwnerExists := false; |
| } |
| } |
| |
| action(tv_allocateTBE, "tv", desc="allocate TBE Entry for TCC transactions") { |
| check_allocate(TBEs); |
| peek(w_TCCRequest_in, CPURequestMsg) { |
| TBEs.allocate(address); |
| set_tbe(TBEs.lookup(address)); |
| tbe.DataBlk := in_msg.DataBlk; // Data only for WBs |
| tbe.Dirty := false; |
| tbe.OriginalRequestor := in_msg.Requestor; |
| tbe.NumPendingAcks := 0; |
| tbe.UntransferredOwnerExists := false; |
| } |
| } |
| |
| action(t_allocateTBE, "t", desc="allocate TBE Entry") { |
| check_allocate(TBEs);//check whether resources are full |
| peek(coreRequestNetwork_in, CPURequestMsg) { |
| TBEs.allocate(address); |
| set_tbe(TBEs.lookup(address)); |
| tbe.DataBlk := cache_entry.DataBlk; // Data only for WBs |
| tbe.Dirty := false; |
| tbe.Upgrade := false; |
| tbe.OriginalRequestor := in_msg.Requestor; |
| tbe.NumPendingAcks := 0; |
| tbe.UntransferredOwnerExists := false; |
| tbe.Sender := machineID; |
| } |
| } |
| |
| action(tr_allocateTBE, "tr", desc="allocate TBE Entry for recall") { |
| check_allocate(TBEs);//check whether resources are full |
| TBEs.allocate(address); |
| set_tbe(TBEs.lookup(address)); |
| tbe.DataBlk := cache_entry.DataBlk; // Data only for WBs |
| tbe.Dirty := false; |
| tbe.Upgrade := false; |
| tbe.OriginalRequestor := machineID; //Recall request, Self initiated |
| tbe.NumPendingAcks := 0; |
| tbe.UntransferredOwnerExists := false; |
| } |
| |
| action(dt_deallocateTBE, "dt", desc="Deallocate TBE entry") { |
| TBEs.deallocate(address); |
| unset_tbe(); |
| } |
| |
| |
| action(d_allocateDir, "d", desc="allocate Directory Cache") { |
| if (is_invalid(cache_entry)) { |
| set_cache_entry(directory.allocate(address, new Entry)); |
| } |
| } |
| |
| action(dd_deallocateDir, "dd", desc="deallocate Directory Cache") { |
| if (is_valid(cache_entry)) { |
| directory.deallocate(address); |
| } |
| unset_cache_entry(); |
| } |
| |
| action(ss_sendStaleNotification, "ss", desc="stale data; nothing to writeback") { |
| enqueue(responseToNB_out, ResponseMsg, issue_latency) { |
| out_msg.addr := address; |
| out_msg.Type := CoherenceResponseType:StaleNotif; |
| out_msg.Destination.add(map_Address_to_Directory(address)); |
| out_msg.Sender := machineID; |
| out_msg.MessageSize := MessageSizeType:Response_Control; |
| } |
| } |
| |
| action(wb_data, "wb", desc="write back data") { |
| enqueue(responseToNB_out, ResponseMsg, issue_latency) { |
| out_msg.addr := address; |
| out_msg.Type := CoherenceResponseType:CPUData; |
| out_msg.Sender := machineID; |
| out_msg.Destination.add(map_Address_to_Directory(address)); |
| out_msg.DataBlk := tbe.DataBlk; |
| out_msg.Dirty := tbe.Dirty; |
| if (tbe.Shared) { |
| out_msg.NbReqShared := true; |
| } else { |
| out_msg.NbReqShared := false; |
| } |
| out_msg.State := CoherenceState:Shared; // faux info |
| out_msg.MessageSize := MessageSizeType:Writeback_Data; |
| DPRINTF(RubySlicc, "%s\n", out_msg); |
| } |
| } |
| |
| action(sf_setSharedFlip, "sf", desc="hit by shared probe, status may be different") { |
| assert(is_valid(tbe)); |
| tbe.Shared := true; |
| } |
| |
| action(y_writeDataToTBE, "y", desc="write Probe Data to TBE") { |
| peek(responseNetwork_in, ResponseMsg) { |
| if (!tbe.Dirty || in_msg.Dirty) { |
| tbe.DataBlk := in_msg.DataBlk; |
| tbe.Dirty := in_msg.Dirty; |
| } |
| if (in_msg.Hit) { |
| tbe.Cached := true; |
| } |
| } |
| } |
| |
| action(ty_writeTCCDataToTBE, "ty", desc="write TCC Probe Data to TBE") { |
| peek(w_TCCResponse_in, ResponseMsg) { |
| if (!tbe.Dirty || in_msg.Dirty) { |
| tbe.DataBlk := in_msg.DataBlk; |
| tbe.Dirty := in_msg.Dirty; |
| } |
| if (in_msg.Hit) { |
| tbe.Cached := true; |
| } |
| } |
| } |
| |
| |
| action(ut_updateTag, "ut", desc="update Tag (i.e. set MRU)") { |
| directory.setMRU(address); |
| } |
| |
| // TRANSITIONS |
| |
| // Handling TCP/SQC requests (similar to how NB dir handles TCC events with some changes to account for stateful directory). |
| |
| |
| // transitions from base |
| transition(I, RdBlk, I_ES){TagArrayRead} { |
| d_allocateDir; |
| t_allocateTBE; |
| n_issueRdBlk; |
| i_popIncomingRequestQueue; |
| } |
| |
| transition(I, RdBlkS, I_S){TagArrayRead} { |
| d_allocateDir; |
| t_allocateTBE; |
| nS_issueRdBlkS; |
| i_popIncomingRequestQueue; |
| } |
| |
| |
| transition(I_S, NB_AckS, BBB_S) { |
| fa_forwardSysAck; |
| pR_popResponseFromNBQueue; |
| } |
| |
| transition(I_ES, NB_AckS, BBB_S) { |
| fa_forwardSysAck; |
| pR_popResponseFromNBQueue; |
| } |
| |
| transition(I_ES, NB_AckE, BBB_E) { |
| fa_forwardSysAck; |
| pR_popResponseFromNBQueue; |
| } |
| |
| transition({S_M, O_M}, {NB_AckCtoD,NB_AckM}, BBB_M) { |
| fa_forwardSysAck; |
| pR_popResponseFromNBQueue; |
| } |
| |
| transition(I_M, NB_AckM, BBB_M) { |
| fa_forwardSysAck; |
| pR_popResponseFromNBQueue; |
| } |
| |
| transition(BBB_M, CoreUnblock, M){TagArrayWrite} { |
| c_clearOwner; |
| cc_clearSharers; |
| e_ownerIsUnblocker; |
| uu_sendUnblock; |
| dt_deallocateTBE; |
| j_popIncomingUnblockQueue; |
| } |
| |
| transition(BBB_S, CoreUnblock, S){TagArrayWrite} { |
| as_addToSharers; |
| uu_sendUnblock; |
| dt_deallocateTBE; |
| j_popIncomingUnblockQueue; |
| } |
| |
| transition(BBB_E, CoreUnblock, E){TagArrayWrite} { |
| as_addToSharers; |
| uu_sendUnblock; |
| dt_deallocateTBE; |
| j_popIncomingUnblockQueue; |
| } |
| |
| |
| transition(I, RdBlkM, I_M){TagArrayRead} { |
| d_allocateDir; |
| t_allocateTBE; |
| nM_issueRdBlkM; |
| i_popIncomingRequestQueue; |
| } |
| |
| // |
| transition(S, {RdBlk, RdBlkS}, BBS_S){TagArrayRead} { |
| t_allocateTBE; |
| sc_probeShrCoreData; |
| s2_probeShrL2Data; |
| q_addOutstandingMergedSharer; |
| i_popIncomingRequestQueue; |
| } |
| // Merging of read sharing into a single request |
| transition(BBS_S, {RdBlk, RdBlkS}) { |
| q_addOutstandingMergedSharer; |
| i_popIncomingRequestQueue; |
| } |
| // Wait for probe acks to be complete |
| transition(BBS_S, CPUPrbResp) { |
| ccr_copyCoreResponseToTBE; |
| x_decrementAcks; |
| o_checkForAckCompletion; |
| pk_popResponseQueue; |
| } |
| |
| transition(BBS_S, TCCPrbResp) { |
| ctr_copyTCCResponseToTBE; |
| x_decrementAcks; |
| o_checkForAckCompletion; |
| plr_popTCCResponseQueue; |
| } |
| |
| // Window for merging complete with this transition |
| // Send responses to all outstanding |
| transition(BBS_S, ProbeAcksComplete, BB_S) { |
| sCS_sendCollectiveResponseS; |
| pt_popTriggerQueue; |
| } |
| |
| transition(BB_S, CoreUnblock, BB_S) { |
| m_addUnlockerToSharers; |
| j_popIncomingUnblockQueue; |
| } |
| |
| transition(BB_S, LastCoreUnblock, S) { |
| m_addUnlockerToSharers; |
| dt_deallocateTBE; |
| j_popIncomingUnblockQueue; |
| } |
| |
| transition(O, {RdBlk, RdBlkS}, BBO_O){TagArrayRead} { |
| t_allocateTBE; |
| pso_probeSharedDataOwner; |
| q_addOutstandingMergedSharer; |
| i_popIncomingRequestQueue; |
| } |
| // Merging of read sharing into a single request |
| transition(BBO_O, {RdBlk, RdBlkS}) { |
| q_addOutstandingMergedSharer; |
| i_popIncomingRequestQueue; |
| } |
| |
| // Wait for probe acks to be complete |
| transition(BBO_O, CPUPrbResp) { |
| ccr_copyCoreResponseToTBE; |
| x_decrementAcks; |
| o_checkForAckCompletion; |
| pk_popResponseQueue; |
| } |
| |
| transition(BBO_O, TCCPrbResp) { |
| ctr_copyTCCResponseToTBE; |
| x_decrementAcks; |
| o_checkForAckCompletion; |
| plr_popTCCResponseQueue; |
| } |
| |
| // Window for merging complete with this transition |
| // Send responses to all outstanding |
| transition(BBO_O, ProbeAcksComplete, BB_OO) { |
| sCS_sendCollectiveResponseS; |
| pt_popTriggerQueue; |
| } |
| |
| transition(BB_OO, CoreUnblock) { |
| m_addUnlockerToSharers; |
| j_popIncomingUnblockQueue; |
| } |
| |
| transition(BB_OO, LastCoreUnblock, O){TagArrayWrite} { |
| m_addUnlockerToSharers; |
| dt_deallocateTBE; |
| j_popIncomingUnblockQueue; |
| } |
| |
| transition(S, CPUWrite, BW_S){TagArrayRead} { |
| t_allocateTBE; |
| rC_removeCoreFromSharers; |
| sT_sendRequestToTCC; |
| i_popIncomingRequestQueue; |
| } |
| |
| transition(E, CPUWrite, BW_E){TagArrayRead} { |
| t_allocateTBE; |
| rC_removeCoreFromSharers; |
| sT_sendRequestToTCC; |
| i_popIncomingRequestQueue; |
| } |
| |
| transition(O, CPUWrite, BW_O){TagArrayRead} { |
| t_allocateTBE; |
| rCo_removeCoreFromOwner; |
| rC_removeCoreFromSharers; |
| sT_sendRequestToTCC; |
| i_popIncomingRequestQueue; |
| } |
| |
| transition(M, CPUWrite, BW_M){TagArrayRead} { |
| t_allocateTBE; |
| rCo_removeCoreFromOwner; |
| rC_removeCoreFromSharers; |
| sT_sendRequestToTCC; |
| i_popIncomingRequestQueue; |
| } |
| |
| transition(BW_S, TCCUnblock_Sharer, S){TagArrayWrite} { |
| aT_addTCCToSharers; |
| dt_deallocateTBE; |
| plu_popTCCUnblockQueue; |
| } |
| |
| transition(BW_S, TCCUnblock_NotValid, S){TagArrayWrite} { |
| dt_deallocateTBE; |
| plu_popTCCUnblockQueue; |
| } |
| |
| transition(BW_E, TCCUnblock, E){TagArrayWrite} { |
| cc_clearSharers; |
| aT_addTCCToSharers; |
| dt_deallocateTBE; |
| plu_popTCCUnblockQueue; |
| } |
| |
| transition(BW_E, TCCUnblock_NotValid, E) { |
| dt_deallocateTBE; |
| plu_popTCCUnblockQueue; |
| } |
| |
| transition(BW_M, TCCUnblock, M) { |
| c_clearOwner; |
| cc_clearSharers; |
| eT_ownerIsUnblocker; |
| dt_deallocateTBE; |
| plu_popTCCUnblockQueue; |
| } |
| |
| transition(BW_M, TCCUnblock_NotValid, M) { |
| // Note this transition should only be executed if we received a stale wb |
| dt_deallocateTBE; |
| plu_popTCCUnblockQueue; |
| } |
| |
| transition(BW_O, TCCUnblock, O) { |
| c_clearOwner; |
| eT_ownerIsUnblocker; |
| dt_deallocateTBE; |
| plu_popTCCUnblockQueue; |
| } |
| |
| transition(BW_O, TCCUnblock_NotValid, O) { |
| // Note this transition should only be executed if we received a stale wb |
| dt_deallocateTBE; |
| plu_popTCCUnblockQueue; |
| } |
| |
| // We lost the owner likely do to an invalidation racing with a 'O' wb |
| transition(BW_O, TCCUnblock_Sharer, S) { |
| c_clearOwner; |
| aT_addTCCToSharers; |
| dt_deallocateTBE; |
| plu_popTCCUnblockQueue; |
| } |
| |
| transition({BW_M, BW_S, BW_E, BW_O}, {PrbInv,PrbInvData,PrbShrData}) { |
| ww_recycleProbeRequest; |
| } |
| |
| transition(BRWD_I, {PrbInvData, PrbInv, PrbShrData}) { |
| ww_recycleProbeRequest; |
| } |
| |
| // Three step process: locally invalidate others, issue CtoD, wait for NB_AckCtoD |
| transition(S, CtoD, BBS_UM) {TagArrayRead} { |
| t_allocateTBE; |
| lpc_probeInvCore; |
| i2_probeInvL2; |
| o_checkForAckCompletion; |
| i_popIncomingRequestQueue; |
| } |
| |
| transition(BBS_UM, CPUPrbResp, BBS_UM) { |
| x_decrementAcks; |
| o_checkForAckCompletion; |
| pk_popResponseQueue; |
| } |
| |
| transition(BBS_UM, TCCPrbResp) { |
| x_decrementAcks; |
| o_checkForAckCompletion; |
| plr_popTCCResponseQueue; |
| } |
| |
| transition(BBS_UM, ProbeAcksComplete, S_M) { |
| rU_rememberUpgrade; |
| nM_issueRdBlkM; |
| pt_popTriggerQueue; |
| } |
| |
| // Three step process: locally invalidate others, issue CtoD, wait for NB_AckCtoD |
| transition(O, CtoD, BBO_UM){TagArrayRead} { |
| t_allocateTBE; |
| lpc_probeInvCore; |
| i2_probeInvL2; |
| o_checkForAckCompletion; |
| i_popIncomingRequestQueue; |
| } |
| |
| transition(BBO_UM, CPUPrbResp, BBO_UM) { |
| ruo_rememberUntransferredOwner; |
| x_decrementAcks; |
| o_checkForAckCompletion; |
| pk_popResponseQueue; |
| } |
| |
| transition(BBO_UM, TCCPrbResp) { |
| ruoT_rememberUntransferredOwnerTCC; |
| x_decrementAcks; |
| o_checkForAckCompletion; |
| plr_popTCCResponseQueue; |
| } |
| |
| transition(BBO_UM, ProbeAcksComplete, O_M) { |
| rU_rememberUpgrade; |
| nM_issueRdBlkM; |
| pt_popTriggerQueue; |
| } |
| |
| transition({S,E}, RdBlkM, BBS_M){TagArrayWrite} { |
| t_allocateTBE; |
| ldc_probeInvCoreData; |
| ld2_probeInvL2Data; |
| o_checkForAckCompletion; |
| i_popIncomingRequestQueue; |
| } |
| |
| transition(BBS_M, CPUPrbResp) { |
| ccr_copyCoreResponseToTBE; |
| rR_removeResponderFromSharers; |
| x_decrementAcks; |
| o_checkForAckCompletion; |
| pk_popResponseQueue; |
| } |
| |
| transition(BBS_M, TCCPrbResp) { |
| ctr_copyTCCResponseToTBE; |
| x_decrementAcks; |
| o_checkForAckCompletion; |
| plr_popTCCResponseQueue; |
| } |
| |
| transition(BBS_M, ProbeAcksComplete, S_M) { |
| nM_issueRdBlkM; |
| pt_popTriggerQueue; |
| } |
| |
| transition(O, RdBlkM, BBO_M){TagArrayRead} { |
| t_allocateTBE; |
| ldc_probeInvCoreData; |
| ld2_probeInvL2Data; |
| o_checkForAckCompletion; |
| i_popIncomingRequestQueue; |
| } |
| |
| transition(BBO_M, CPUPrbResp) { |
| ccr_copyCoreResponseToTBE; |
| rR_removeResponderFromSharers; |
| x_decrementAcks; |
| o_checkForAckCompletion; |
| pk_popResponseQueue; |
| } |
| |
| transition(BBO_M, TCCPrbResp) { |
| ctr_copyTCCResponseToTBE; |
| x_decrementAcks; |
| o_checkForAckCompletion; |
| plr_popTCCResponseQueue; |
| } |
| |
| transition(BBO_M, ProbeAcksComplete, O_M) { |
| nM_issueRdBlkM; |
| pt_popTriggerQueue; |
| } |
| |
| // |
| transition(M, RdBlkM, BBM_M){TagArrayRead} { |
| t_allocateTBE; |
| ldc_probeInvCoreData; |
| ld2_probeInvL2Data; |
| i_popIncomingRequestQueue; |
| } |
| |
| transition(BBM_M, CPUPrbResp) { |
| ccr_copyCoreResponseToTBE; |
| x_decrementAcks; |
| o_checkForAckCompletion; |
| pk_popResponseQueue; |
| } |
| |
| // TCP recalled block before receiving probe |
| transition({BBM_M, BBS_M, BBO_M}, {CPUWrite,NoCPUWrite}) { |
| zz_recycleRequest; |
| } |
| |
| transition(BBM_M, TCCPrbResp) { |
| ctr_copyTCCResponseToTBE; |
| x_decrementAcks; |
| o_checkForAckCompletion; |
| plr_popTCCResponseQueue; |
| } |
| |
| transition(BBM_M, ProbeAcksComplete, BB_M) { |
| sM_sendResponseM; |
| pt_popTriggerQueue; |
| } |
| |
| transition(BB_M, CoreUnblock, M){TagArrayWrite} { |
| e_ownerIsUnblocker; |
| dt_deallocateTBE; |
| j_popIncomingUnblockQueue; |
| } |
| |
| transition(M, {RdBlkS, RdBlk}, BBM_O){TagArrayRead} { |
| t_allocateTBE; |
| sc_probeShrCoreData; |
| s2_probeShrL2Data; |
| i_popIncomingRequestQueue; |
| } |
| |
| transition(E, {RdBlkS, RdBlk}, BBM_O){TagArrayRead} { |
| t_allocateTBE; |
| eto_moveExSharerToOwner; |
| sc_probeShrCoreData; |
| s2_probeShrL2Data; |
| i_popIncomingRequestQueue; |
| } |
| |
| transition(BBM_O, CPUPrbResp) { |
| ccr_copyCoreResponseToTBE; |
| x_decrementAcks; |
| o_checkForAckCompletion; |
| pk_popResponseQueue; |
| } |
| transition(BBM_O, TCCPrbResp) { |
| ctr_copyTCCResponseToTBE; |
| x_decrementAcks; |
| o_checkForAckCompletion; |
| plr_popTCCResponseQueue; |
| } |
| transition(BBM_O, ProbeAcksComplete, BB_O) { |
| sS_sendResponseS; |
| pt_popTriggerQueue; |
| } |
| |
| transition(BB_O, CoreUnblock, O){TagArrayWrite} { |
| as_addToSharers; |
| dt_deallocateTBE; |
| j_popIncomingUnblockQueue; |
| } |
| |
| transition({BBO_O, BBM_M, BBS_S, BBM_O, BB_M, BB_O, BB_S, BBO_UM, BBS_UM, BBS_M, BBO_M, BB_OO}, {PrbInvData, PrbInv,PrbShrData}) { |
| ww_recycleProbeRequest; |
| } |
| |
| transition({BBM_O, BBS_S, CP_S, CP_O, CP_SM, CP_OM, BBO_O}, {CPUWrite,NoCPUWrite}) { |
| zz_recycleRequest; |
| } |
| |
| // stale CtoD raced with external invalidation |
| transition({I, CP_I, B_I, CP_IOM, CP_ISM, CP_OSIW, BRWD_I, BRW_I, BRD_I}, CtoD) { |
| i_popIncomingRequestQueue; |
| } |
| |
| // stale CtoD raced with internal RdBlkM |
| transition({BBM_M, BBS_M, BBO_M, BBB_M, BBS_UM, BBO_UM}, CtoD) { |
| i_popIncomingRequestQueue; |
| } |
| |
| transition({E, M}, CtoD) { |
| i_popIncomingRequestQueue; |
| } |
| |
| |
| // TCC-directory has sent out (And potentially received acks for) probes. |
| // TCP/SQC replacement (known to be stale subsequent) are popped off. |
| transition({BBO_UM, BBS_UM}, {CPUWrite,NoCPUWrite}) { |
| nC_sendNullWBAckToCore; |
| i_popIncomingRequestQueue; |
| } |
| |
| transition(S_M, {NoCPUWrite, CPUWrite}) { |
| zz_recycleRequest; |
| } |
| |
| transition(O_M, {NoCPUWrite, CPUWrite}) { |
| zz_recycleRequest; |
| } |
| |
| |
| transition({BBM_M, BBS_M, BBO_M, BBO_UM, BBS_UM}, {VicDirty, VicClean, VicDirtyLast, NoVic}) { |
| nT_sendNullWBAckToTCC; |
| pl_popTCCRequestQueue; |
| } |
| |
| transition({CP_S, CP_O, CP_OM, CP_SM}, {VicDirty, VicClean, VicDirtyLast, CancelWB, NoVic}) { |
| yy_recycleTCCRequestQueue; |
| } |
| |
| // However, when TCCdir has sent out PrbSharedData, one cannot ignore. |
| transition({BBS_S, BBO_O, BBM_O, S_M, O_M, BBB_M, BBB_S, BBB_E}, {VicDirty, VicClean, VicDirtyLast,CancelWB}) { |
| yy_recycleTCCRequestQueue; |
| } |
| |
| transition({BW_S,BW_E,BW_O, BW_M}, {VicDirty, VicClean, VicDirtyLast, NoVic}) { |
| yy_recycleTCCRequestQueue; |
| } |
| |
| transition({BW_S,BW_E,BW_O, BW_M}, CancelWB) { |
| nT_sendNullWBAckToTCC; |
| pl_popTCCRequestQueue; |
| } |
| |
| |
| /// recycle if waiting for unblocks. |
| transition({BB_M,BB_O,BB_S,BB_OO}, {VicDirty, VicClean, VicDirtyLast,NoVic,CancelWB}) { |
| yy_recycleTCCRequestQueue; |
| } |
| |
| transition({BBS_S, BBO_O}, NoVic) { |
| rT_removeTCCFromSharers; |
| nT_sendNullWBAckToTCC; |
| pl_popTCCRequestQueue; |
| } |
| |
| // stale. Pop message and send dummy ack. |
| transition({I_S, I_ES, I_M}, {VicDirty, VicClean, VicDirtyLast, NoVic}) { |
| nT_sendNullWBAckToTCC; |
| pl_popTCCRequestQueue; |
| } |
| |
| transition(M, VicDirtyLast, VM_I){TagArrayRead} { |
| tv_allocateTBE; |
| vd_victim; |
| pl_popTCCRequestQueue; |
| } |
| |
| transition(E, VicDirty, VM_I){TagArrayRead} { |
| tv_allocateTBE; |
| vd_victim; |
| pl_popTCCRequestQueue; |
| } |
| |
| transition(O, VicDirty, VO_S){TagArrayRead} { |
| tv_allocateTBE; |
| vd_victim; |
| pl_popTCCRequestQueue; |
| } |
| |
| transition(O, {VicDirtyLast, VicClean}, VO_I){TagArrayRead} { |
| tv_allocateTBE; |
| vd_victim; |
| pl_popTCCRequestQueue; |
| } |
| |
| transition({E, S}, VicClean, VES_I){TagArrayRead} { |
| tv_allocateTBE; |
| vc_victim; |
| pl_popTCCRequestQueue; |
| } |
| |
| transition({O, S}, NoVic){TagArrayRead} { |
| rT_removeTCCFromSharers; |
| nT_sendNullWBAckToTCC; |
| pl_popTCCRequestQueue; |
| } |
| |
| transition({O,S}, NoCPUWrite){TagArrayRead} { |
| rC_removeCoreFromSharers; |
| nC_sendNullWBAckToCore; |
| i_popIncomingRequestQueue; |
| } |
| |
| transition({M,E}, NoCPUWrite){TagArrayRead} { |
| rC_removeCoreFromSharers; |
| nC_sendNullWBAckToCore; |
| i_popIncomingRequestQueue; |
| } |
| |
| // This can only happen if it is race. (TCCdir sent out probes which caused this cancel in the first place.) |
| transition({VM_I, VES_I, VO_I}, CancelWB) { |
| pl_popTCCRequestQueue; |
| } |
| |
| transition({VM_I, VES_I, VO_I}, NB_AckWB, I){TagArrayWrite} { |
| c_clearOwner; |
| cc_clearSharers; |
| wb_data; |
| fw2_forwardWBAck; |
| dt_deallocateTBE; |
| dd_deallocateDir; |
| pR_popResponseFromNBQueue; |
| } |
| |
| transition(VO_S, NB_AckWB, S){TagArrayWrite} { |
| c_clearOwner; |
| wb_data; |
| fw2_forwardWBAck; |
| dt_deallocateTBE; |
| pR_popResponseFromNBQueue; |
| } |
| |
| transition(I_C, NB_AckWB, I){TagArrayWrite} { |
| c_clearOwner; |
| cc_clearSharers; |
| ss_sendStaleNotification; |
| fw2_forwardWBAck; |
| dt_deallocateTBE; |
| dd_deallocateDir; |
| pR_popResponseFromNBQueue; |
| } |
| |
| transition(I_W, NB_AckWB, I) { |
| ss_sendStaleNotification; |
| dt_deallocateTBE; |
| dd_deallocateDir; |
| pR_popResponseFromNBQueue; |
| } |
| |
| |
| |
| // Do not handle replacements, reads of any kind or writebacks from transients; recycle |
| transition({I_M, I_ES, I_S, MO_I, ES_I, S_M, O_M, VES_I, VO_I, VO_S, VM_I, I_C, I_W}, {RdBlkS,RdBlkM,RdBlk,CtoD}) { |
| zz_recycleRequest; |
| } |
| |
| transition( VO_S, NoCPUWrite) { |
| zz_recycleRequest; |
| } |
| |
| transition({BW_M, BW_S, BW_O, BW_E}, {RdBlkS,RdBlkM,RdBlk,CtoD,NoCPUWrite, CPUWrite}) { |
| zz_recycleRequest; |
| } |
| |
| transition({BBB_M, BBB_S, BBB_E, BB_O, BB_M, BB_S, BB_OO}, { RdBlk, RdBlkS, RdBlkM, CPUWrite, NoCPUWrite}) { |
| zz_recycleRequest; |
| } |
| |
| transition({BBB_S, BBB_E, BB_O, BB_S, BB_OO}, { CtoD}) { |
| zz_recycleRequest; |
| } |
| |
| transition({BBS_UM, BBO_UM, BBM_M, BBM_O, BBS_M, BBO_M}, { RdBlk, RdBlkS, RdBlkM}) { |
| zz_recycleRequest; |
| } |
| |
| transition(BBM_O, CtoD) { |
| zz_recycleRequest; |
| } |
| |
| transition({BBS_S, BBO_O}, {RdBlkM, CtoD}) { |
| zz_recycleRequest; |
| } |
| |
| transition({B_I, CP_I, CP_S, CP_O, CP_OM, CP_SM, CP_IOM, CP_ISM, CP_OSIW, BRWD_I, BRW_I, BRD_I}, {RdBlk, RdBlkS, RdBlkM}) { |
| zz_recycleRequest; |
| } |
| |
| transition({CP_O, CP_S, CP_OM}, CtoD) { |
| zz_recycleRequest; |
| } |
| |
| // Ignore replacement related messages after probe got in. |
| transition({CP_I, B_I, CP_IOM, CP_ISM, CP_OSIW, BRWD_I, BRW_I, BRD_I}, {CPUWrite, NoCPUWrite}) { |
| zz_recycleRequest; |
| } |
| |
| // Ignore replacement related messages after probes processed |
| transition({I, I_S, I_ES, I_M, I_C, I_W}, {CPUWrite,NoCPUWrite}) { |
| nC_sendNullWBAckToCore; |
| i_popIncomingRequestQueue; |
| } |
| // cannot ignore cancel... otherwise TCP/SQC will be stuck in I_C |
| transition({I, I_S, I_ES, I_M, I_C, I_W, S_M, M, O, E, S}, CPUWriteCancel){TagArrayRead} { |
| nC_sendNullWBAckToCore; |
| i_popIncomingRequestQueue; |
| } |
| |
| transition({CP_I, B_I, CP_IOM, CP_ISM, BRWD_I, BRW_I, BRD_I}, {NoVic, VicClean, VicDirty, VicDirtyLast}){ |
| nT_sendNullWBAckToTCC; |
| pl_popTCCRequestQueue; |
| } |
| |
| // Handling Probes from NB (General process: (1) propagate up, go to blocking state (2) process acks (3) on last ack downward.) |
| |
| // step 1 |
| transition({M, O, E, S}, PrbInvData, CP_I){TagArrayRead} { |
| tp_allocateTBE; |
| dc_probeInvCoreData; |
| d2_probeInvL2Data; |
| pp_popProbeQueue; |
| } |
| // step 2a |
| transition(CP_I, CPUPrbResp) { |
| y_writeDataToTBE; |
| x_decrementAcks; |
| o_checkForAckCompletion; |
| pk_popResponseQueue; |
| } |
| // step 2b |
| transition(CP_I, TCCPrbResp) { |
| ty_writeTCCDataToTBE; |
| x_decrementAcks; |
| o_checkForAckCompletion; |
| plr_popTCCResponseQueue; |
| } |
| // step 3 |
| transition(CP_I, ProbeAcksComplete, I){TagArrayWrite} { |
| pd_sendProbeResponseData; |
| c_clearOwner; |
| cc_clearSharers; |
| dt_deallocateTBE; |
| dd_deallocateDir; |
| pt_popTriggerQueue; |
| } |
| |
| // step 1 |
| transition({M, O, E, S}, PrbInv, B_I){TagArrayWrite} { |
| tp_allocateTBE; |
| ipc_probeInvCore; |
| i2_probeInvL2; |
| pp_popProbeQueue; |
| } |
| // step 2 |
| transition(B_I, CPUPrbResp) { |
| x_decrementAcks; |
| o_checkForAckCompletion; |
| pk_popResponseQueue; |
| } |
| // step 2b |
| transition(B_I, TCCPrbResp) { |
| x_decrementAcks; |
| o_checkForAckCompletion; |
| plr_popTCCResponseQueue; |
| } |
| // step 3 |
| transition(B_I, ProbeAcksComplete, I){TagArrayWrite} { |
| // send response down to NB |
| pi_sendProbeResponseInv; |
| c_clearOwner; |
| cc_clearSharers; |
| dt_deallocateTBE; |
| dd_deallocateDir; |
| pt_popTriggerQueue; |
| } |
| |
| |
| // step 1 |
| transition({M, O}, PrbShrData, CP_O){TagArrayRead} { |
| tp_allocateTBE; |
| sc_probeShrCoreData; |
| s2_probeShrL2Data; |
| pp_popProbeQueue; |
| } |
| |
| transition(E, PrbShrData, CP_O){TagArrayRead} { |
| tp_allocateTBE; |
| eto_moveExSharerToOwner; |
| sc_probeShrCoreData; |
| s2_probeShrL2Data; |
| pp_popProbeQueue; |
| } |
| // step 2 |
| transition(CP_O, CPUPrbResp) { |
| y_writeDataToTBE; |
| x_decrementAcks; |
| o_checkForAckCompletion; |
| pk_popResponseQueue; |
| } |
| // step 2b |
| transition(CP_O, TCCPrbResp) { |
| ty_writeTCCDataToTBE; |
| x_decrementAcks; |
| o_checkForAckCompletion; |
| plr_popTCCResponseQueue; |
| } |
| // step 3 |
| transition(CP_O, ProbeAcksComplete, O){TagArrayWrite} { |
| // send response down to NB |
| pd_sendProbeResponseData; |
| dt_deallocateTBE; |
| pt_popTriggerQueue; |
| } |
| |
| //step 1 |
| transition(S, PrbShrData, CP_S) { |
| tp_allocateTBE; |
| sc_probeShrCoreData; |
| s2_probeShrL2Data; |
| pp_popProbeQueue; |
| } |
| // step 2 |
| transition(CP_S, CPUPrbResp) { |
| y_writeDataToTBE; |
| x_decrementAcks; |
| o_checkForAckCompletion; |
| pk_popResponseQueue; |
| } |
| // step 2b |
| transition(CP_S, TCCPrbResp) { |
| ty_writeTCCDataToTBE; |
| x_decrementAcks; |
| o_checkForAckCompletion; |
| plr_popTCCResponseQueue; |
| } |
| // step 3 |
| transition(CP_S, ProbeAcksComplete, S) { |
| // send response down to NB |
| pd_sendProbeResponseData; |
| dt_deallocateTBE; |
| pt_popTriggerQueue; |
| } |
| |
| // step 1 |
| transition(O_M, PrbInvData, CP_IOM) { |
| dc_probeInvCoreData; |
| d2_probeInvL2Data; |
| pp_popProbeQueue; |
| } |
| // step 2a |
| transition(CP_IOM, CPUPrbResp) { |
| y_writeDataToTBE; |
| x_decrementAcks; |
| o_checkForAckCompletion; |
| pk_popResponseQueue; |
| } |
| // step 2b |
| transition(CP_IOM, TCCPrbResp) { |
| ty_writeTCCDataToTBE; |
| x_decrementAcks; |
| o_checkForAckCompletion; |
| plr_popTCCResponseQueue; |
| } |
| // step 3 |
| transition(CP_IOM, ProbeAcksComplete, I_M) { |
| pdm_sendProbeResponseDataMs; |
| c_clearOwner; |
| cc_clearSharers; |
| cd_clearDirtyBitTBE; |
| pt_popTriggerQueue; |
| } |
| |
| transition(CP_IOM, ProbeAcksCompleteReissue, I){TagArrayWrite} { |
| pdm_sendProbeResponseDataMs; |
| c_clearOwner; |
| cc_clearSharers; |
| dt_deallocateTBE; |
| dd_deallocateDir; |
| pt_popTriggerQueue; |
| } |
| |
| // step 1 |
| transition(S_M, PrbInvData, CP_ISM) { |
| dc_probeInvCoreData; |
| d2_probeInvL2Data; |
| o_checkForAckCompletion; |
| pp_popProbeQueue; |
| } |
| // step 2a |
| transition(CP_ISM, CPUPrbResp) { |
| y_writeDataToTBE; |
| x_decrementAcks; |
| o_checkForAckCompletion; |
| pk_popResponseQueue; |
| } |
| // step 2b |
| transition(CP_ISM, TCCPrbResp) { |
| ty_writeTCCDataToTBE; |
| x_decrementAcks; |
| o_checkForAckCompletion; |
| plr_popTCCResponseQueue; |
| } |
| // step 3 |
| transition(CP_ISM, ProbeAcksComplete, I_M) { |
| pdm_sendProbeResponseDataMs; |
| c_clearOwner; |
| cc_clearSharers; |
| cd_clearDirtyBitTBE; |
| |
| //dt_deallocateTBE; |
| pt_popTriggerQueue; |
| } |
| transition(CP_ISM, ProbeAcksCompleteReissue, I){TagArrayWrite} { |
| pim_sendProbeResponseInvMs; |
| c_clearOwner; |
| cc_clearSharers; |
| dt_deallocateTBE; |
| dd_deallocateDir; |
| pt_popTriggerQueue; |
| } |
| |
| // step 1 |
| transition({S_M, O_M}, {PrbInv}, CP_ISM) { |
| dc_probeInvCoreData; |
| d2_probeInvL2Data; |
| pp_popProbeQueue; |
| } |
| // next steps inherited from BS_ISM |
| |
| // Simpler cases |
| |
| transition({I_C, I_W}, {PrbInvData, PrbInv, PrbShrData}) { |
| pi_sendProbeResponseInv; |
| pp_popProbeQueue; |
| } |
| |
| //If the directory is certain that the block is not present, one can send an acknowledgement right away. |
| // No need for three step process. |
| transition(I, {PrbInv,PrbShrData,PrbInvData}){TagArrayRead} { |
| pi_sendProbeResponseInv; |
| pp_popProbeQueue; |
| } |
| |
| transition({I_M, I_ES, I_S}, {PrbInv, PrbInvData}) { |
| pi_sendProbeResponseInv; |
| pp_popProbeQueue; |
| } |
| |
| transition({I_M, I_ES, I_S}, PrbShrData) { |
| prm_sendProbeResponseMiss; |
| pp_popProbeQueue; |
| } |
| |
| //step 1 |
| transition(S_M, PrbShrData, CP_SM) { |
| sc_probeShrCoreData; |
| s2_probeShrL2Data; |
| o_checkForAckCompletion; |
| pp_popProbeQueue; |
| } |
| // step 2 |
| transition(CP_SM, CPUPrbResp) { |
| y_writeDataToTBE; |
| x_decrementAcks; |
| o_checkForAckCompletion; |
| pk_popResponseQueue; |
| } |
| // step 2b |
| transition(CP_SM, TCCPrbResp) { |
| ty_writeTCCDataToTBE; |
| x_decrementAcks; |
| o_checkForAckCompletion; |
| plr_popTCCResponseQueue; |
| } |
| // step 3 |
| transition(CP_SM, {ProbeAcksComplete,ProbeAcksCompleteReissue}, S_M){DataArrayRead} { |
| // send response down to NB |
| pd_sendProbeResponseData; |
| pt_popTriggerQueue; |
| } |
| |
| //step 1 |
| transition(O_M, PrbShrData, CP_OM) { |
| sc_probeShrCoreData; |
| s2_probeShrL2Data; |
| pp_popProbeQueue; |
| } |
| // step 2 |
| transition(CP_OM, CPUPrbResp) { |
| y_writeDataToTBE; |
| x_decrementAcks; |
| o_checkForAckCompletion; |
| pk_popResponseQueue; |
| } |
| // step 2b |
| transition(CP_OM, TCCPrbResp) { |
| ty_writeTCCDataToTBE; |
| x_decrementAcks; |
| o_checkForAckCompletion; |
| plr_popTCCResponseQueue; |
| } |
| // step 3 |
| transition(CP_OM, {ProbeAcksComplete,ProbeAcksCompleteReissue}, O_M) { |
| // send response down to NB |
| pd_sendProbeResponseData; |
| pt_popTriggerQueue; |
| } |
| |
| transition(BRW_I, PrbInvData, I_W) { |
| pd_sendProbeResponseData; |
| pp_popProbeQueue; |
| } |
| |
| transition({VM_I,VO_I}, PrbInvData, I_C) { |
| pd_sendProbeResponseData; |
| pp_popProbeQueue; |
| } |
| |
| transition(VES_I, {PrbInvData,PrbInv}, I_C) { |
| pi_sendProbeResponseInv; |
| pp_popProbeQueue; |
| } |
| |
| transition({VM_I, VO_I, BRW_I}, PrbInv, I_W) { |
| pi_sendProbeResponseInv; |
| pp_popProbeQueue; |
| } |
| |
| transition({VM_I, VO_I, VO_S, VES_I, BRW_I}, PrbShrData) { |
| pd_sendProbeResponseData; |
| sf_setSharedFlip; |
| pp_popProbeQueue; |
| } |
| |
| transition(VO_S, PrbInvData, CP_OSIW) { |
| dc_probeInvCoreData; |
| d2_probeInvL2Data; |
| pp_popProbeQueue; |
| } |
| |
| transition(CP_OSIW, TCCPrbResp) { |
| x_decrementAcks; |
| o_checkForAckCompletion; |
| plr_popTCCResponseQueue; |
| } |
| transition(CP_OSIW, CPUPrbResp) { |
| x_decrementAcks; |
| o_checkForAckCompletion; |
| pk_popResponseQueue; |
| } |
| |
| transition(CP_OSIW, ProbeAcksComplete, I_C) { |
| pd_sendProbeResponseData; |
| cd_clearDirtyBitTBE; |
| pt_popTriggerQueue; |
| } |
| |
| transition({I, S, E, O, M, CP_O, CP_S, CP_OM, CP_SM, CP_OSIW, BW_S, BW_E, BW_O, BW_M, I_M, I_ES, I_S, BBS_S, BBO_O, BBM_M, BBM_O, BB_M, BB_O, BB_OO, BB_S, BBS_M, BBO_M, BBO_UM, BBS_UM, S_M, O_M, BBB_S, BBB_M, BBB_E, VES_I, VM_I, VO_I, VO_S, ES_I, MO_I, I_C, I_W}, StaleVic) { |
| nT_sendNullWBAckToTCC; |
| pl_popTCCRequestQueue; |
| } |
| |
| transition({CP_I, B_I, CP_IOM, CP_ISM, BRWD_I, BRW_I, BRD_I}, StaleVic) { |
| nT_sendNullWBAckToTCC; |
| pl_popTCCRequestQueue; |
| } |
| |
| // Recall Transistions |
| // transient states still require the directory state |
| transition({M, O}, Recall, BRWD_I) { |
| tr_allocateTBE; |
| vd_victim; |
| dc_probeInvCoreData; |
| d2_probeInvL2Data; |
| } |
| |
| transition({E, S}, Recall, BRWD_I) { |
| tr_allocateTBE; |
| vc_victim; |
| dc_probeInvCoreData; |
| d2_probeInvL2Data; |
| } |
| |
| transition(I, Recall) { |
| dd_deallocateDir; |
| } |
| |
| transition({BRWD_I, BRD_I}, CPUPrbResp) { |
| y_writeDataToTBE; |
| x_decrementAcks; |
| o_checkForAckCompletion; |
| pk_popResponseQueue; |
| } |
| |
| transition({BRWD_I, BRD_I}, TCCPrbResp) { |
| ty_writeTCCDataToTBE; |
| x_decrementAcks; |
| o_checkForAckCompletion; |
| plr_popTCCResponseQueue; |
| } |
| |
| transition(BRWD_I, NB_AckWB, BRD_I) { |
| pR_popResponseFromNBQueue; |
| } |
| |
| transition(BRWD_I, ProbeAcksComplete, BRW_I) { |
| pt_popTriggerQueue; |
| } |
| |
| transition(BRW_I, NB_AckWB, I) { |
| wb_data; |
| dt_deallocateTBE; |
| dd_deallocateDir; |
| pR_popResponseFromNBQueue; |
| } |
| |
| transition(BRD_I, ProbeAcksComplete, I) { |
| wb_data; |
| dt_deallocateTBE; |
| dd_deallocateDir; |
| pt_popTriggerQueue; |
| } |
| |
| // wait for stable state for Recall |
| transition({BRWD_I,BRD_I,BRW_I,CP_O, CP_S, CP_OM, CP_SM, CP_OSIW, BW_S, BW_E, BW_O, BW_M, I_M, I_ES, I_S, BBS_S, BBO_O, BBM_M, BBM_O, BB_M, BB_O, BB_OO, BB_S, BBS_M, BBO_M, BBO_UM, BBS_UM, S_M, O_M, BBB_S, BBB_M, BBB_E, VES_I, VM_I, VO_I, VO_S, ES_I, MO_I, I_C, I_W, CP_I}, Recall) { |
| zz_recycleRequest; // stall and wait would be for the wrong address |
| ut_updateTag; // try to find an easier recall |
| } |
| |
| } |