Merge ktlim@zizzer:/bk/newmem

into  zamp.eecs.umich.edu:/z/ktlim2/clean/newmem

--HG--
extra : convert_revision : f5b6daa2d512f38153246fc9a39cc6560d939ebc

1 files changed, 567 insertions, 0 deletions

diff --git a/src/mem/cache/coherence/coherence_protocol.cc b/src/mem/cache/coherence/coherence_protocol.cc
new file mode 100644
index 000000000..bcf3ce9c5
--- /dev/null
+++ b/src/mem/cache/coherence/coherence_protocol.cc
@@ -0,0 +1,567 @@
+/*
+ * Copyright (c) 2002-2005 The Regents of The University of Michigan
+ * 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.
+ *
+ * Authors: Erik Hallnor
+ *          Steve Reinhardt
+ *          Ron Dreslinski
+ */
+
+/**
+ * @file
+ * Definitions of CoherenceProtocol.
+ */
+
+#include <string>
+
+#include "base/misc.hh"
+#include "mem/cache/miss/mshr.hh"
+#include "mem/cache/cache.hh"
+#include "mem/cache/coherence/coherence_protocol.hh"
+#include "sim/builder.hh"
+
+using namespace std;
+
+
+CoherenceProtocol::StateTransition::StateTransition()
+    : busCmd(Packet::InvalidCmd), newState(-1), snoopFunc(invalidTransition)
+{
+}
+
+
+void
+CoherenceProtocol::regStats()
+{
+    // Even though we count all the possible transitions in the
+    // requestCount and snoopCount arrays, most of these are invalid,
+    // so we just select the interesting ones to print here.
+
+    requestCount[Invalid][Packet::ReadReq]
+        .name(name() + ".read_invalid")
+        .desc("read misses to invalid blocks")
+        ;
+
+    requestCount[Invalid][Packet::WriteReq]
+        .name(name() +".write_invalid")
+        .desc("write misses to invalid blocks")
+        ;
+
+    requestCount[Invalid][Packet::SoftPFReq]
+        .name(name() +".swpf_invalid")
+        .desc("soft prefetch misses to invalid blocks")
+        ;
+
+    requestCount[Invalid][Packet::HardPFReq]
+        .name(name() +".hwpf_invalid")
+        .desc("hard prefetch misses to invalid blocks")
+        ;
+
+    requestCount[Shared][Packet::WriteReq]
+        .name(name() + ".write_shared")
+        .desc("write misses to shared blocks")
+        ;
+
+    requestCount[Owned][Packet::WriteReq]
+        .name(name() + ".write_owned")
+        .desc("write misses to owned blocks")
+        ;
+
+    snoopCount[Shared][Packet::ReadReq]
+        .name(name() + ".snoop_read_shared")
+        .desc("read snoops on shared blocks")
+        ;
+
+    snoopCount[Shared][Packet::ReadExReq]
+        .name(name() + ".snoop_readex_shared")
+        .desc("readEx snoops on shared blocks")
+        ;
+
+    snoopCount[Shared][Packet::UpgradeReq]
+        .name(name() + ".snoop_upgrade_shared")
+        .desc("upgradee snoops on shared blocks")
+        ;
+
+    snoopCount[Modified][Packet::ReadReq]
+        .name(name() + ".snoop_read_modified")
+        .desc("read snoops on modified blocks")
+        ;
+
+    snoopCount[Modified][Packet::ReadExReq]
+        .name(name() + ".snoop_readex_modified")
+        .desc("readEx snoops on modified blocks")
+        ;
+
+    snoopCount[Owned][Packet::ReadReq]
+        .name(name() + ".snoop_read_owned")
+        .desc("read snoops on owned blocks")
+        ;
+
+    snoopCount[Owned][Packet::ReadExReq]
+        .name(name() + ".snoop_readex_owned")
+        .desc("readEx snoops on owned blocks")
+        ;
+
+    snoopCount[Owned][Packet::UpgradeReq]
+        .name(name() + ".snoop_upgrade_owned")
+        .desc("upgrade snoops on owned blocks")
+        ;
+
+    snoopCount[Exclusive][Packet::ReadReq]
+        .name(name() + ".snoop_read_exclusive")
+        .desc("read snoops on exclusive blocks")
+        ;
+
+    snoopCount[Exclusive][Packet::ReadExReq]
+        .name(name() + ".snoop_readex_exclusive")
+        .desc("readEx snoops on exclusive blocks")
+        ;
+
+    snoopCount[Shared][Packet::InvalidateReq]
+        .name(name() + ".snoop_inv_shared")
+        .desc("Invalidate snoops on shared blocks")
+        ;
+
+    snoopCount[Owned][Packet::InvalidateReq]
+        .name(name() + ".snoop_inv_owned")
+        .desc("Invalidate snoops on owned blocks")
+        ;
+
+    snoopCount[Exclusive][Packet::InvalidateReq]
+        .name(name() + ".snoop_inv_exclusive")
+        .desc("Invalidate snoops on exclusive blocks")
+        ;
+
+    snoopCount[Modified][Packet::InvalidateReq]
+        .name(name() + ".snoop_inv_modified")
+        .desc("Invalidate snoops on modified blocks")
+        ;
+
+    snoopCount[Invalid][Packet::InvalidateReq]
+        .name(name() + ".snoop_inv_invalid")
+        .desc("Invalidate snoops on invalid blocks")
+        ;
+
+    snoopCount[Shared][Packet::WriteInvalidateReq]
+        .name(name() + ".snoop_writeinv_shared")
+        .desc("WriteInvalidate snoops on shared blocks")
+        ;
+
+    snoopCount[Owned][Packet::WriteInvalidateReq]
+        .name(name() + ".snoop_writeinv_owned")
+        .desc("WriteInvalidate snoops on owned blocks")
+        ;
+
+    snoopCount[Exclusive][Packet::WriteInvalidateReq]
+        .name(name() + ".snoop_writeinv_exclusive")
+        .desc("WriteInvalidate snoops on exclusive blocks")
+        ;
+
+    snoopCount[Modified][Packet::WriteInvalidateReq]
+        .name(name() + ".snoop_writeinv_modified")
+        .desc("WriteInvalidate snoops on modified blocks")
+        ;
+
+    snoopCount[Invalid][Packet::WriteInvalidateReq]
+        .name(name() + ".snoop_writeinv_invalid")
+        .desc("WriteInvalidate snoops on invalid blocks")
+        ;
+}
+
+
+bool
+CoherenceProtocol::invalidateTrans(BaseCache *cache, Packet * &pkt,
+                                   CacheBlk *blk, MSHR *mshr,
+                                   CacheBlk::State & new_state)
+{
+    // invalidate the block
+    new_state = (blk->status & ~stateMask) | Invalid;
+    return false;
+}
+
+
+bool
+CoherenceProtocol::supplyTrans(BaseCache *cache, Packet * &pkt,
+                               CacheBlk *blk,
+                               MSHR *mshr,
+                               CacheBlk::State & new_state
+                               )
+{
+    return true;
+}
+
+
+bool
+CoherenceProtocol::supplyAndGotoSharedTrans(BaseCache *cache, Packet * &pkt,
+                                            CacheBlk *blk,
+                                            MSHR *mshr,
+                                            CacheBlk::State & new_state)
+{
+    new_state = (blk->status & ~stateMask) | Shared;
+    pkt->flags |= SHARED_LINE;
+    return supplyTrans(cache, pkt, blk, mshr, new_state);
+}
+
+
+bool
+CoherenceProtocol::supplyAndGotoOwnedTrans(BaseCache *cache, Packet * &pkt,
+                                           CacheBlk *blk,
+                                           MSHR *mshr,
+                                           CacheBlk::State & new_state)
+{
+    new_state = (blk->status & ~stateMask) | Owned;
+    pkt->flags |= SHARED_LINE;
+    return supplyTrans(cache, pkt, blk, mshr, new_state);
+}
+
+
+bool
+CoherenceProtocol::supplyAndInvalidateTrans(BaseCache *cache, Packet * &pkt,
+                                            CacheBlk *blk,
+                                            MSHR *mshr,
+                                            CacheBlk::State & new_state)
+{
+    new_state = (blk->status & ~stateMask) | Invalid;
+    return supplyTrans(cache, pkt, blk, mshr, new_state);
+}
+
+bool
+CoherenceProtocol::assertShared(BaseCache *cache, Packet * &pkt,
+                                            CacheBlk *blk,
+                                            MSHR *mshr,
+                                            CacheBlk::State & new_state)
+{
+    new_state = (blk->status & ~stateMask) | Shared;
+    pkt->flags |= SHARED_LINE;
+    return false;
+}
+
+CoherenceProtocol::CoherenceProtocol(const string &name,
+                                     const string &protocol,
+                                     const bool doUpgrades)
+    : SimObject(name)
+{
+    if ((protocol == "mosi" || protocol == "moesi") && !doUpgrades) {
+        cerr << "CoherenceProtocol: ownership protocols require upgrade transactions"
+             << "(write miss on owned block generates ReadExcl, which will clobber dirty block)"
+             << endl;
+        fatal("");
+    }
+
+    Packet::Command writeToSharedCmd = doUpgrades ? Packet::UpgradeReq : Packet::ReadExReq;
+    Packet::Command writeToSharedResp = doUpgrades ? Packet::UpgradeResp : Packet::ReadExResp;
+
+//@todo add in hardware prefetch to this list
+    if (protocol == "msi") {
+        // incoming requests: specify outgoing bus request
+        transitionTable[Invalid][Packet::ReadReq].onRequest(Packet::ReadReq);
+        transitionTable[Invalid][Packet::WriteReq].onRequest(Packet::ReadExReq);
+        transitionTable[Shared][Packet::WriteReq].onRequest(writeToSharedCmd);
+        //Prefetching causes a read
+        transitionTable[Invalid][Packet::SoftPFReq].onRequest(Packet::ReadReq);
+        transitionTable[Invalid][Packet::HardPFReq].onRequest(Packet::ReadReq);
+
+        // on response to given request: specify new state
+        transitionTable[Invalid][Packet::ReadResp].onResponse(Shared);
+        transitionTable[Invalid][Packet::ReadExResp].onResponse(Modified);
+        transitionTable[Shared][writeToSharedResp].onResponse(Modified);
+
+        // bus snoop transition functions
+        transitionTable[Invalid][Packet::ReadReq].onSnoop(nullTransition);
+        transitionTable[Invalid][Packet::ReadExReq].onSnoop(nullTransition);
+        transitionTable[Shared][Packet::ReadReq].onSnoop(nullTransition);
+        transitionTable[Shared][Packet::ReadExReq].onSnoop(invalidateTrans);
+        transitionTable[Modified][Packet::ReadExReq].onSnoop(supplyAndInvalidateTrans);
+        transitionTable[Modified][Packet::ReadReq].onSnoop(supplyAndGotoSharedTrans);
+        //Tansitions on seeing a DMA (writeInv(samelevel) or DMAInv)
+        transitionTable[Invalid][Packet::InvalidateReq].onSnoop(invalidateTrans);
+        transitionTable[Shared][Packet::InvalidateReq].onSnoop(invalidateTrans);
+        transitionTable[Modified][Packet::InvalidateReq].onSnoop(invalidateTrans);
+        transitionTable[Invalid][Packet::WriteInvalidateReq].onSnoop(invalidateTrans);
+        transitionTable[Shared][Packet::WriteInvalidateReq].onSnoop(invalidateTrans);
+        transitionTable[Modified][Packet::WriteInvalidateReq].onSnoop(invalidateTrans);
+
+        if (doUpgrades) {
+            transitionTable[Invalid][Packet::UpgradeReq].onSnoop(nullTransition);
+            transitionTable[Shared][Packet::UpgradeReq].onSnoop(invalidateTrans);
+        }
+    }
+
+    else if(protocol == "mesi") {
+        // incoming requests: specify outgoing bus request
+        transitionTable[Invalid][Packet::ReadReq].onRequest(Packet::ReadReq);
+        transitionTable[Invalid][Packet::WriteReq].onRequest(Packet::ReadExReq);
+        transitionTable[Shared][Packet::WriteReq].onRequest(writeToSharedCmd);
+        //Prefetching causes a read
+        transitionTable[Invalid][Packet::SoftPFReq].onRequest(Packet::ReadReq);
+        transitionTable[Invalid][Packet::HardPFReq].onRequest(Packet::ReadReq);
+
+        // on response to given request: specify new state
+        transitionTable[Invalid][Packet::ReadResp].onResponse(Exclusive);
+        //It will move into shared if the shared line is asserted in the
+        //getNewState function
+        transitionTable[Invalid][Packet::ReadExResp].onResponse(Modified);
+        transitionTable[Shared][writeToSharedResp].onResponse(Modified);
+
+        // bus snoop transition functions
+        transitionTable[Invalid][Packet::ReadReq].onSnoop(nullTransition);
+        transitionTable[Invalid][Packet::ReadExReq].onSnoop(nullTransition);
+        transitionTable[Shared][Packet::ReadReq].onSnoop(assertShared);
+        transitionTable[Shared][Packet::ReadExReq].onSnoop(invalidateTrans);
+        transitionTable[Exclusive][Packet::ReadReq].onSnoop(assertShared);
+        transitionTable[Exclusive][Packet::ReadExReq].onSnoop(invalidateTrans);
+        transitionTable[Modified][Packet::ReadExReq].onSnoop(supplyAndInvalidateTrans);
+        transitionTable[Modified][Packet::ReadReq].onSnoop(supplyAndGotoSharedTrans);
+        //Tansitions on seeing a DMA (writeInv(samelevel) or DMAInv)
+        transitionTable[Invalid][Packet::InvalidateReq].onSnoop(invalidateTrans);
+        transitionTable[Shared][Packet::InvalidateReq].onSnoop(invalidateTrans);
+        transitionTable[Modified][Packet::InvalidateReq].onSnoop(invalidateTrans);
+        transitionTable[Exclusive][Packet::InvalidateReq].onSnoop(invalidateTrans);
+        transitionTable[Invalid][Packet::WriteInvalidateReq].onSnoop(invalidateTrans);
+        transitionTable[Shared][Packet::WriteInvalidateReq].onSnoop(invalidateTrans);
+        transitionTable[Modified][Packet::WriteInvalidateReq].onSnoop(invalidateTrans);
+        transitionTable[Exclusive][Packet::WriteInvalidateReq].onSnoop(invalidateTrans);
+
+        if (doUpgrades) {
+            transitionTable[Invalid][Packet::UpgradeReq].onSnoop(nullTransition);
+            transitionTable[Shared][Packet::UpgradeReq].onSnoop(invalidateTrans);
+        }
+    }
+
+    else if(protocol == "mosi") {
+        // incoming requests: specify outgoing bus request
+        transitionTable[Invalid][Packet::ReadReq].onRequest(Packet::ReadReq);
+        transitionTable[Invalid][Packet::WriteReq].onRequest(Packet::ReadExReq);
+        transitionTable[Shared][Packet::WriteReq].onRequest(writeToSharedCmd);
+        transitionTable[Owned][Packet::WriteReq].onRequest(writeToSharedCmd);
+        //Prefetching causes a read
+        transitionTable[Invalid][Packet::SoftPFReq].onRequest(Packet::ReadReq);
+        transitionTable[Invalid][Packet::HardPFReq].onRequest(Packet::ReadReq);
+
+        // on response to given request: specify new state
+        transitionTable[Invalid][Packet::ReadResp].onResponse(Shared);
+        transitionTable[Invalid][Packet::ReadExResp].onResponse(Modified);
+        transitionTable[Shared][writeToSharedResp].onResponse(Modified);
+        transitionTable[Owned][writeToSharedResp].onResponse(Modified);
+
+        // bus snoop transition functions
+        transitionTable[Invalid][Packet::ReadReq].onSnoop(nullTransition);
+        transitionTable[Invalid][Packet::ReadExReq].onSnoop(nullTransition);
+        transitionTable[Invalid][Packet::UpgradeReq].onSnoop(nullTransition);
+        transitionTable[Shared][Packet::ReadReq].onSnoop(assertShared);
+        transitionTable[Shared][Packet::ReadExReq].onSnoop(invalidateTrans);
+        transitionTable[Shared][Packet::UpgradeReq].onSnoop(invalidateTrans);
+        transitionTable[Modified][Packet::ReadExReq].onSnoop(supplyAndInvalidateTrans);
+        transitionTable[Modified][Packet::ReadReq].onSnoop(supplyAndGotoOwnedTrans);
+        transitionTable[Owned][Packet::ReadReq].onSnoop(supplyAndGotoOwnedTrans);
+        transitionTable[Owned][Packet::ReadExReq].onSnoop(supplyAndInvalidateTrans);
+        transitionTable[Owned][Packet::UpgradeReq].onSnoop(invalidateTrans);
+        //Tansitions on seeing a DMA (writeInv(samelevel) or DMAInv)
+        transitionTable[Invalid][Packet::InvalidateReq].onSnoop(invalidateTrans);
+        transitionTable[Shared][Packet::InvalidateReq].onSnoop(invalidateTrans);
+        transitionTable[Modified][Packet::InvalidateReq].onSnoop(invalidateTrans);
+        transitionTable[Owned][Packet::InvalidateReq].onSnoop(invalidateTrans);
+        transitionTable[Invalid][Packet::WriteInvalidateReq].onSnoop(invalidateTrans);
+        transitionTable[Shared][Packet::WriteInvalidateReq].onSnoop(invalidateTrans);
+        transitionTable[Modified][Packet::WriteInvalidateReq].onSnoop(invalidateTrans);
+        transitionTable[Owned][Packet::WriteInvalidateReq].onSnoop(invalidateTrans);
+    }
+
+    else if(protocol == "moesi") {
+        // incoming requests: specify outgoing bus request
+        transitionTable[Invalid][Packet::ReadReq].onRequest(Packet::ReadReq);
+        transitionTable[Invalid][Packet::WriteReq].onRequest(Packet::ReadExReq);
+        transitionTable[Shared][Packet::WriteReq].onRequest(writeToSharedCmd);
+        transitionTable[Owned][Packet::WriteReq].onRequest(writeToSharedCmd);
+        //Prefetching causes a read
+        transitionTable[Invalid][Packet::SoftPFReq].onRequest(Packet::ReadReq);
+        transitionTable[Invalid][Packet::HardPFReq].onRequest(Packet::ReadReq);
+
+        // on response to given request: specify new state
+        transitionTable[Invalid][Packet::ReadResp].onResponse(Exclusive);
+        //It will move into shared if the shared line is asserted in the
+        //getNewState function
+        transitionTable[Invalid][Packet::ReadExResp].onResponse(Modified);
+        transitionTable[Shared][writeToSharedResp].onResponse(Modified);
+        transitionTable[Owned][writeToSharedResp].onResponse(Modified);
+
+        // bus snoop transition functions
+        transitionTable[Invalid][Packet::ReadReq].onSnoop(nullTransition);
+        transitionTable[Invalid][Packet::ReadExReq].onSnoop(nullTransition);
+        transitionTable[Invalid][Packet::UpgradeReq].onSnoop(nullTransition);
+        transitionTable[Shared][Packet::ReadReq].onSnoop(assertShared);
+        transitionTable[Shared][Packet::ReadExReq].onSnoop(invalidateTrans);
+        transitionTable[Shared][Packet::UpgradeReq].onSnoop(invalidateTrans);
+        transitionTable[Exclusive][Packet::ReadReq].onSnoop(assertShared);
+        transitionTable[Exclusive][Packet::ReadExReq].onSnoop(invalidateTrans);
+        transitionTable[Modified][Packet::ReadReq].onSnoop(supplyAndGotoOwnedTrans);
+        transitionTable[Modified][Packet::ReadExReq].onSnoop(supplyAndInvalidateTrans);
+        transitionTable[Owned][Packet::ReadReq].onSnoop(supplyAndGotoOwnedTrans);
+        transitionTable[Owned][Packet::ReadExReq].onSnoop(supplyAndInvalidateTrans);
+        transitionTable[Owned][Packet::UpgradeReq].onSnoop(invalidateTrans);
+        //Transitions on seeing a DMA (writeInv(samelevel) or DMAInv)
+        transitionTable[Invalid][Packet::InvalidateReq].onSnoop(invalidateTrans);
+        transitionTable[Shared][Packet::InvalidateReq].onSnoop(invalidateTrans);
+        transitionTable[Exclusive][Packet::InvalidateReq].onSnoop(invalidateTrans);
+        transitionTable[Modified][Packet::InvalidateReq].onSnoop(invalidateTrans);
+        transitionTable[Owned][Packet::InvalidateReq].onSnoop(invalidateTrans);
+        transitionTable[Invalid][Packet::WriteInvalidateReq].onSnoop(invalidateTrans);
+        transitionTable[Shared][Packet::WriteInvalidateReq].onSnoop(invalidateTrans);
+        transitionTable[Exclusive][Packet::WriteInvalidateReq].onSnoop(invalidateTrans);
+        transitionTable[Modified][Packet::WriteInvalidateReq].onSnoop(invalidateTrans);
+        transitionTable[Owned][Packet::WriteInvalidateReq].onSnoop(invalidateTrans);
+    }
+
+    else {
+        cerr << "CoherenceProtocol: unrecognized protocol " << protocol
+             <<  endl;
+        fatal("");
+    }
+}
+
+
+Packet::Command
+CoherenceProtocol::getBusCmd(Packet::Command cmdIn, CacheBlk::State state,
+                             MSHR *mshr)
+{
+    state &= stateMask;
+    int cmd_idx = (int) cmdIn;
+
+    assert(0 <= state && state <= stateMax);
+    assert(0 <= cmd_idx && cmd_idx < NUM_MEM_CMDS);
+
+    Packet::Command cmdOut = transitionTable[state][cmd_idx].busCmd;
+
+    assert(cmdOut != Packet::InvalidCmd);
+
+    ++requestCount[state][cmd_idx];
+
+    return cmdOut;
+}
+
+
+CacheBlk::State
+CoherenceProtocol::getNewState(Packet * &pkt, CacheBlk::State oldState)
+{
+    CacheBlk::State state = oldState & stateMask;
+    int cmd_idx = pkt->cmdToIndex();
+
+    assert(0 <= state && state <= stateMax);
+    assert(0 <= cmd_idx && cmd_idx < NUM_MEM_CMDS);
+
+    CacheBlk::State newState = transitionTable[state][cmd_idx].newState;
+
+    //Check if it's exclusive and the shared line was asserted,
+    //then  goto shared instead
+    if (newState == Exclusive && (pkt->flags & SHARED_LINE)) {
+        newState = Shared;
+    }
+
+    assert(newState != -1);
+
+    //Make sure not to loose any other state information
+    newState = (oldState & ~stateMask) | newState;
+    return newState;
+}
+
+
+bool
+CoherenceProtocol::handleBusRequest(BaseCache *cache, Packet * &pkt,
+                                    CacheBlk *blk,
+                                    MSHR *mshr,
+                                    CacheBlk::State & new_state)
+{
+    if (blk == NULL) {
+        // nothing to do if we don't have a block
+        return false;
+    }
+
+    CacheBlk::State state = blk->status & stateMask;
+    int cmd_idx = pkt->cmdToIndex();
+
+    assert(0 <= state && state <= stateMax);
+    assert(0 <= cmd_idx && cmd_idx < NUM_MEM_CMDS);
+
+//    assert(mshr == NULL); // can't currently handle outstanding requests
+    //Check first if MSHR, and also insure, if there is one, that it is not in service
+    assert(!mshr || mshr->inService == 0);
+    ++snoopCount[state][cmd_idx];
+
+    bool ret = transitionTable[state][cmd_idx].snoopFunc(cache, pkt, blk, mshr,
+                                                     new_state);
+
+
+
+    return ret;
+}
+
+bool
+CoherenceProtocol::nullTransition(BaseCache *cache, Packet * &pkt,
+                                  CacheBlk *blk, MSHR *mshr,
+                                  CacheBlk::State & new_state)
+{
+    // do nothing
+    if (blk)
+        new_state = blk->status;
+    return false;
+}
+
+
+bool
+CoherenceProtocol::invalidTransition(BaseCache *cache, Packet * &pkt,
+                                     CacheBlk *blk, MSHR *mshr,
+                                     CacheBlk::State & new_state)
+{
+    panic("Invalid transition");
+    return false;
+}
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+BEGIN_DECLARE_SIM_OBJECT_PARAMS(CoherenceProtocol)
+
+    Param<string> protocol;
+    Param<bool> do_upgrades;
+
+END_DECLARE_SIM_OBJECT_PARAMS(CoherenceProtocol)
+
+
+BEGIN_INIT_SIM_OBJECT_PARAMS(CoherenceProtocol)
+
+    INIT_PARAM(protocol, "name of coherence protocol"),
+    INIT_PARAM_DFLT(do_upgrades, "use upgrade transactions?", true)
+
+END_INIT_SIM_OBJECT_PARAMS(CoherenceProtocol)
+
+
+CREATE_SIM_OBJECT(CoherenceProtocol)
+{
+    return new CoherenceProtocol(getInstanceName(), protocol,
+                                 do_upgrades);
+}
+
+REGISTER_SIM_OBJECT("CoherenceProtocol", CoherenceProtocol)
+
+#endif // DOXYGEN_SHOULD_SKIP_THIS