diff options
Diffstat (limited to 'src/mem/protocol/MSI_MOSI_CMP_directory-dir.sm')
| -rw-r--r-- | src/mem/protocol/MSI_MOSI_CMP_directory-dir.sm | 497 |
1 files changed, 497 insertions, 0 deletions
diff --git a/src/mem/protocol/MSI_MOSI_CMP_directory-dir.sm b/src/mem/protocol/MSI_MOSI_CMP_directory-dir.sm new file mode 100644 index 000000000..435bf0eff --- /dev/null +++ b/src/mem/protocol/MSI_MOSI_CMP_directory-dir.sm @@ -0,0 +1,497 @@ + +/* + * Copyright (c) 1999-2005 Mark D. Hill and David A. Wood + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer; + * 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; + * neither the name of the copyright holders 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 + * OWNER 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. + */ + +/* + * $Id$ + */ + +machine(Directory, "MOSI Directory Optimized") { + + // ** OUT QUEUES ** + MessageBuffer dummyFrom0, network="To", virtual_network="0", ordered="false"; // dummy buffer that shouldn't be used + MessageBuffer dummyFrom1, network="To", virtual_network="1", ordered="false"; // dummy buffer that shouldn't be used + // Dir -> mod-L2 bank - Must be true for the 'opt' and 'GS' protocols BE CAREFUL HERE!!! + MessageBuffer forwardedRequestFromDir, network="To", virtual_network="2", ordered="true"; + MessageBuffer responseFromDir, network="To", virtual_network="3", ordered="false"; // Dir -> mod-L2 bank + MessageBuffer dummyFrom4, network="To", virtual_network="4", ordered="false"; // dummy buffer that shouldn't be used + + // ** IN QUEUES ** + MessageBuffer dummyTo0, network="From", virtual_network="0", ordered="false"; // dummy buffer that shouldn't be used + MessageBuffer requestToDir, network="From", virtual_network="1", ordered="false"; // a mod-L2 bank -> this Dir + MessageBuffer dummyTo2, network="From", virtual_network="2", ordered="false"; // dummy buffer that shouldn't be used + MessageBuffer dummyTo3, network="From", virtual_network="3", ordered="false"; // dummy buffer that shouldn't be used + MessageBuffer finalAckToDir, network="From", virtual_network="4", ordered="false"; // a mod-L2 bank -> this Dir + + // STATES + enumeration(State, desc="Directory states", default="Directory_State_NP") { + // Base states + NP, desc="Not present"; + I, desc="Idle"; + S, desc="Shared"; + O, desc="Owned"; + M, desc="Modified", format="!b"; + OO, desc="transient state of O->GetS/GetInstr->O"; + OM, desc="transient state of O->GetX->M"; + MO, desc="transient state of M->GetS/GetInstr->O"; + MM, desc="transient state of M->GetX->M"; + } + + // Events + enumeration(Event, desc="Directory events") { + GETS, desc="A GETS arrives"; + GET_INSTR, desc=""; + GETX_Owner, desc="A GETX arrives, requestor is owner"; + GETX_NotOwner, desc="A GETX arrives, requestor is not owner"; + PUTX_Owner, "PUTX (requestor is owner)", desc="A PUTX arrives, requestor is owner"; + PUTX_NotOwner, "PUTX (requestor not owner)",desc="A PUTX arrives, requestor is not owner"; + FinalAck, desc=""; + } + + // TYPES + + // DirectoryEntry + structure(Entry, desc="...") { + State DirectoryState, desc="Directory state"; + Set Sharers, desc="Set of sharers - must be L2 caches"; // Note this is a Set and not a NetDest for space concerns + bool DirOwner, default="true", desc="Is dir owner?"; + NodeID ProcOwner, default="0", desc="Processor owner"; // Note this is an int for space concerns + DataBlock DataBlk, desc="data for the block"; + } + + external_type(DirectoryMemory) { + Entry lookup(Address); + bool isPresent(Address); + } + + // ** OBJECTS ** + + DirectoryMemory directory, constructor_hack="i"; + + State getState(Address addr) { + if (directory.isPresent(addr)) { + return directory[addr].DirectoryState; + } + return State:NP; + } + + string getDirStateStr(Address addr) { + return Directory_State_to_string(getState(addr)); + } + + string getRequestTypeStr(CoherenceRequestType type) { + return CoherenceRequestType_to_string(type); + } + + void setState(Address addr, State state) { + if (directory.isPresent(addr)) { + DEBUG_EXPR(addr); + DEBUG_EXPR(directory[addr].DirectoryState); + directory[addr].DirectoryState := state; + DEBUG_EXPR(directory[addr].DirectoryState); + DEBUG_EXPR(state); + } + } + + // ** OUT_PORTS ** + out_port(forwardedRequestNetwork_out, RequestMsg, forwardedRequestFromDir); + out_port(responseNetwork_out, ResponseMsg, responseFromDir); + out_port(ownRequestQueue_out, RequestMsg, requestToDir); + + // ** IN_PORTS ** + in_port(dummyTo0_in, RequestMsg, dummyTo0) { + if (dummyTo0_in.isReady()) { + peek(dummyTo0_in, RequestMsg) { + DEBUG_EXPR(in_msg.Address); + DEBUG_EXPR(id); + DEBUG_EXPR(in_msg.Type); + DEBUG_EXPR(getState(in_msg.Address)); + DEBUG_EXPR(in_msg.RequestorMachId); + } + error("dummyTo0 port should not be used"); + } + } + in_port(dummyTo2_in, RequestMsg, dummyTo2) { + if (dummyTo2_in.isReady()) { + peek(dummyTo2_in, RequestMsg) { + DEBUG_EXPR(in_msg.Address); + DEBUG_EXPR(id); + DEBUG_EXPR(in_msg.Type); + DEBUG_EXPR(getState(in_msg.Address)); + DEBUG_EXPR(in_msg.RequestorMachId); + } + error("dummyTo2 port should not be used"); + } + } + + in_port(dummyTo3_in, RequestMsg, dummyTo3) { + if (dummyTo3_in.isReady()) { + peek(dummyTo3_in, RequestMsg) { + DEBUG_EXPR(in_msg.Address); + DEBUG_EXPR(id); + DEBUG_EXPR(in_msg.Type); + DEBUG_EXPR(getState(in_msg.Address)); + DEBUG_EXPR(in_msg.RequestorMachId); + } + error("dummyTo3 port should not be used"); + } + } + + in_port(finalAckNetwork_in, ResponseMsg, finalAckToDir){ + if(finalAckNetwork_in.isReady()){ + peek(finalAckNetwork_in, ResponseMsg){ + assert(in_msg.Destination.isElement(machineID)); + if(in_msg.Type == CoherenceResponseType:FINALACK){ + trigger(Event:FinalAck, in_msg.Address); + } else { + error("Invalid message"); + } + } + } + } + + in_port(requestNetwork_in, RequestMsg, requestToDir) { + if (requestNetwork_in.isReady()) { + peek(requestNetwork_in, RequestMsg) { + assert(in_msg.Destination.isElement(machineID)); + if (in_msg.Type == CoherenceRequestType:GETS) { + trigger(Event:GETS, in_msg.Address); + } else if (in_msg.Type == CoherenceRequestType:GET_INSTR) { + trigger(Event:GET_INSTR, in_msg.Address); + } else if (in_msg.Type == CoherenceRequestType:GETX) { + if(directory[in_msg.Address].DirOwner == false && + L2CacheMachIDToChipID(in_msg.RequestorMachId) == directory[in_msg.Address].ProcOwner) { + trigger(Event:GETX_Owner, in_msg.Address); + } else { + trigger(Event:GETX_NotOwner, in_msg.Address); + } + } else if (in_msg.Type == CoherenceRequestType:PUTX) { + if (directory[in_msg.Address].DirOwner == false && + L2CacheMachIDToChipID(in_msg.RequestorMachId) == directory[in_msg.Address].ProcOwner) { + trigger(Event:PUTX_Owner, in_msg.Address); + } else { + trigger(Event:PUTX_NotOwner, in_msg.Address); + } + } else { + error("Invalid message"); + } + } + } + } + + + // Actions + + // a_addRequestorToSharers + + action(a_addRequestorToSharers, "a", desc="Add requestor to list of sharers") { + peek(requestNetwork_in, RequestMsg) { + directory[address].Sharers.add(L2CacheMachIDToChipID(in_msg.RequestorMachId)); + DEBUG_EXPR(directory[address].Sharers); + } + } + + // b_dataToRequestor + + action(b_dataToRequestor, "b", desc="Send data to requestor") { + peek(requestNetwork_in, RequestMsg) { + enqueue(responseNetwork_out, ResponseMsg, latency="MEMORY_LATENCY") { + out_msg.Address := address; + out_msg.Type := CoherenceResponseType:DATA; + out_msg.SenderMachId := machineID; + if(in_msg.Type == CoherenceRequestType:GETX) { + DEBUG_EXPR(directory[address].Sharers); + DEBUG_EXPR(directory[address].Sharers.count()); + out_msg.NumPendingExtAcks := directory[address].Sharers.count(); + } else { + out_msg.NumPendingExtAcks := 0; // don't need to send pending ack count to GETS requestor + } + out_msg.Destination.add(in_msg.RequestorMachId); + out_msg.DataBlk := directory[address].DataBlk; + DEBUG_EXPR(out_msg.Address); + DEBUG_EXPR(out_msg.DataBlk); + DEBUG_EXPR(out_msg.NumPendingExtAcks); + DEBUG_EXPR(out_msg.Destination); + out_msg.MessageSize := MessageSizeType:Data; + } + } + } + + // d_forwardRequestToOwner + + action(d_forwardRequestToOwner, "d", desc="Forward request to owner") { + peek(requestNetwork_in, RequestMsg) { + enqueue(forwardedRequestNetwork_out, RequestMsg, latency="DIRECTORY_LATENCY") { + out_msg.Address := address; + out_msg.Type := in_msg.Type; + out_msg.RequestorMachId := in_msg.RequestorMachId; + out_msg.Destination.add(map_L2ChipId_to_L2Cache(out_msg.Address, directory[address].ProcOwner)); + DEBUG_EXPR(out_msg.Destination); + + if(in_msg.Type == CoherenceRequestType:GETX) { + out_msg.NumPendingExtAcks := directory[address].Sharers.count(); + } else { + out_msg.NumPendingExtAcks := 0; // don't need to send pending ack count to GETS requestor + } + out_msg.MessageSize := MessageSizeType:Control; + DEBUG_EXPR(out_msg.Address); + DEBUG_EXPR(out_msg.NumPendingExtAcks); + DEBUG_EXPR(out_msg.Destination); + } + } + } + + action(f_setOwnerToRequestor, "f", desc="Set owner equal to requestor") { + peek(requestNetwork_in, RequestMsg) { + directory[address].ProcOwner := L2CacheMachIDToChipID(in_msg.RequestorMachId); + directory[address].DirOwner := false; + } + DEBUG_EXPR(directory[address].ProcOwner); + } + + action(g_clearSharers, "g", desc="Clear list of sharers") { + directory[address].Sharers.clear(); + } + + // currently done via multicast message + + action(h_invToSharers, "h", desc="Send INVs to all sharers") { + peek(requestNetwork_in, RequestMsg) { + DEBUG_EXPR(directory[address].Sharers.count()); + if(directory[address].Sharers.count() != 0){ + enqueue(forwardedRequestNetwork_out, RequestMsg, latency="DIRECTORY_LATENCY") { + out_msg.Address := address; + out_msg.Type := CoherenceRequestType:INV; + out_msg.RequestorMachId := in_msg.RequestorMachId; + DEBUG_EXPR(directory[address].Sharers); + out_msg.Destination := getMultiStaticL2BankNetDest(address, directory[address].Sharers); + out_msg.MessageSize := MessageSizeType:Control; + } + } + } + DEBUG_EXPR(directory[address].Sharers); + } + + action(j_popIncomingRequestQueue, "j", desc="Pop incoming request queue") { + profileMsgDelay(1, requestNetwork_in.dequeue_getDelayCycles()); + } + + action(l_writeRequestDataToMemory, "l", desc="Write PUTX/DWN data to memory") { + peek(requestNetwork_in, RequestMsg) { + directory[in_msg.Address].DataBlk := in_msg.DataBlk; + DEBUG_EXPR(in_msg.Address); + DEBUG_EXPR(in_msg.DataBlk); + } + } + + action(n_writebackAckToRequestor, "n", desc="Send WB_ack to requestor") { + peek(requestNetwork_in, RequestMsg) { + // This needs to be DIRECTORY_LATENCY to keep the queue fifo + enqueue(forwardedRequestNetwork_out, RequestMsg, latency="DIRECTORY_LATENCY") { + out_msg.Address := address; + out_msg.Type := CoherenceRequestType:WB_ACK; + out_msg.RequestorMachId := machineID; + out_msg.Destination.add(in_msg.RequestorMachId); + out_msg.MessageSize := MessageSizeType:Control; + } + } + } + + action(m_forwardExclusiveRequestToOwner, "m", desc="Send EXE_ack to requestor") { + peek(requestNetwork_in, RequestMsg) { + // This needs to be DIRECTORY_LATENCY to keep the queue fifo + enqueue(forwardedRequestNetwork_out, RequestMsg, latency="DIRECTORY_LATENCY") { + out_msg.Address := address; + out_msg.Type := CoherenceRequestType:EXE_ACK; + out_msg.RequestorMachId := machineID; + out_msg.Destination.add(in_msg.RequestorMachId); + out_msg.MessageSize := MessageSizeType:Control; + } + } + } + + action(uu_profile, "u/", desc="Profile this transition.") { + peek(requestNetwork_in, RequestMsg) { + profile_request(in_msg.L1CacheStateStr, in_msg.L2CacheStateStr, getDirStateStr(address), getRequestTypeStr(in_msg.Type)); + } + } + + action(p_clearOwner, "p", desc="Clear owner") { + directory[address].DirOwner := true; // set owner equal to dir + } + + action(r_addOwnerToSharers, "r", desc="Add owner to list of sharers") { + DEBUG_EXPR(directory[address].ProcOwner); + directory[address].Sharers.add(directory[address].ProcOwner); + DEBUG_EXPR(directory[address].Sharers); + } + + action(t_removeOwnerFromSharers, "t", desc="Remove owner from list of sharers") { + DEBUG_EXPR(directory[address].ProcOwner); + directory[address].Sharers.remove(directory[address].ProcOwner); + DEBUG_EXPR(directory[address].Sharers); + } + + action(u_removeRequestorFromSharers, "u", desc="Remove requestor from list of sharers") { + peek(requestNetwork_in, RequestMsg) { + DEBUG_EXPR(in_msg.RequestorMachId); + directory[address].Sharers.remove(L2CacheMachIDToChipID(in_msg.RequestorMachId)); + DEBUG_EXPR(directory[address].Sharers); + } + } + + action(x_recycleRequest, "x", desc=""){ + peek(requestNetwork_in, RequestMsg) { + enqueue(ownRequestQueue_out, RequestMsg, latency="RECYCLE_LATENCY"){ + out_msg := in_msg; + } + } + } + + action(hh_popFinalAckQueue, "\h", desc=""){ + profileMsgDelay(4, finalAckNetwork_in.dequeue_getDelayCycles()); + } + + //action(z_stall, "z", desc=""){ + //} + + // TRANSITIONS + + transition({OM,MM}, FinalAck, M){ + hh_popFinalAckQueue; + } + transition({OO,MO}, FinalAck, O){ + hh_popFinalAckQueue; + } + + transition({OO, OM, MO, MM}, {GETS, GET_INSTR, GETX_Owner, GETX_NotOwner, PUTX_Owner}){ + x_recycleRequest; + j_popIncomingRequestQueue; + // z_stall; + } + + // --------------------------- + + transition({NP, I, S, M, O, OO, OM, MO, MM}, PUTX_NotOwner) { + uu_profile; + n_writebackAckToRequestor; + j_popIncomingRequestQueue; + } + + // Transitions from Idle + transition({NP,I}, {GETS,GET_INSTR}, S) { + uu_profile; + a_addRequestorToSharers; + b_dataToRequestor; + j_popIncomingRequestQueue; + } + + transition({NP,I}, GETX_NotOwner, M) { + uu_profile; + f_setOwnerToRequestor; + b_dataToRequestor; + j_popIncomingRequestQueue; + } + + // Transitions from Shared + transition(S, {GETS,GET_INSTR}) { + uu_profile; + a_addRequestorToSharers; + b_dataToRequestor; + j_popIncomingRequestQueue; + } + + transition(S, GETX_NotOwner, M) { + uu_profile; + u_removeRequestorFromSharers; + b_dataToRequestor; + f_setOwnerToRequestor; + h_invToSharers; + g_clearSharers; + j_popIncomingRequestQueue; + } + + // Transitions from Owned + transition(O, {GETS,GET_INSTR}, OO) { + uu_profile; + a_addRequestorToSharers; + d_forwardRequestToOwner; + j_popIncomingRequestQueue; + } + + transition(O, {GETX_NotOwner, GETX_Owner}, OM) { + uu_profile; + u_removeRequestorFromSharers; + t_removeOwnerFromSharers; + d_forwardRequestToOwner; + f_setOwnerToRequestor; + h_invToSharers; + g_clearSharers; + j_popIncomingRequestQueue; + } + + transition(O, PUTX_Owner, S) { + uu_profile; + u_removeRequestorFromSharers; + l_writeRequestDataToMemory; + n_writebackAckToRequestor; + p_clearOwner; + j_popIncomingRequestQueue; + } + + + // Transitions from Modified + transition(M, {GETS,GET_INSTR}, MO) { + uu_profile; + a_addRequestorToSharers; + r_addOwnerToSharers; + d_forwardRequestToOwner; + j_popIncomingRequestQueue; + } + + transition(M, GETX_NotOwner, MM) { + uu_profile; + d_forwardRequestToOwner; + f_setOwnerToRequestor; + j_popIncomingRequestQueue; + } + + transition(M, GETX_Owner) { + uu_profile; + m_forwardExclusiveRequestToOwner; + j_popIncomingRequestQueue; + } + + transition(M, PUTX_Owner, I) { + uu_profile; + l_writeRequestDataToMemory; + n_writebackAckToRequestor; + p_clearOwner; + j_popIncomingRequestQueue; + } +} |