Merge with head.

[gem5.git] / src / mem / packet.hh

diff --git a/src/mem/packet.hh b/src/mem/packet.hh
index 16bc6f458e6846a1117f872a18f407de65718ca0..2b650a51e2e8d3d46bbcd906b58885cd9c570755 100644 (file)
--- a/src/mem/packet.hh
+++ b/src/mem/packet.hh
@@ -252,9 +252,15 @@ class Packet : public FastAlloc
     bool destValid;
 
     enum Flag {
-        // Snoop flags
+        // Snoop response flags
         MemInhibit,
         Shared,
+        // Special control flags
+        /// Special timing-mode atomic snoop for multi-level coherence.
+        ExpressSnoop,
+        /// Does supplier have exclusive copy?
+        /// Useful for multi-level coherence.
+        SupplyExclusive,
         NUM_PACKET_FLAGS
     };
 
@@ -313,10 +319,16 @@ class Packet : public FastAlloc
 
     // Snoop flags
     void assertMemInhibit()     { flags[MemInhibit] = true; }
-    void assertShared()         { flags[Shared] = true; }
     bool memInhibitAsserted()   { return flags[MemInhibit]; }
+    void assertShared()         { flags[Shared] = true; }
     bool sharedAsserted()       { return flags[Shared]; }
 
+    // Special control flags
+    void setExpressSnoop()      { flags[ExpressSnoop] = true; }
+    bool isExpressSnoop()       { return flags[ExpressSnoop]; }
+    void setSupplyExclusive()   { flags[SupplyExclusive] = true; }
+    bool isSupplyExclusive()    { return flags[SupplyExclusive]; }
+
     // Network error conditions... encapsulate them as methods since
     // their encoding keeps changing (from result field to command
     // field, etc.)
@@ -368,19 +380,20 @@ class Packet : public FastAlloc
     }
 
     /** Alternate constructor for copying a packet.  Copy all fields
-     * *except* set data allocation as static... even if the original
-     * packet's data was dynamic, we don't want to free it when the
-     * new packet is deallocated.  Note that if original packet used
-     * dynamic data, user must guarantee that the new packet's
-     * lifetime is less than that of the original packet. */
-    Packet(Packet *origPkt)
+     * *except* if the original packet's data was dynamic, don't copy
+     * that, as we can't guarantee that the new packet's lifetime is
+     * less than that of the original packet.  In this case the new
+     * packet should allocate its own data. */
+    Packet(Packet *origPkt, bool clearFlags = false)
         :  cmd(origPkt->cmd), req(origPkt->req),
-           data(NULL), staticData(false), dynamicData(false), arrayData(false),
+           data(origPkt->staticData ? origPkt->data : NULL),
+           staticData(origPkt->staticData),
+           dynamicData(false), arrayData(false),
            addr(origPkt->addr), size(origPkt->size),
            src(origPkt->src), dest(origPkt->dest),
            addrSizeValid(origPkt->addrSizeValid),
            srcValid(origPkt->srcValid), destValid(origPkt->destValid),
-           flags(origPkt->flags),
+           flags(clearFlags ? 0 : origPkt->flags),
            time(curTick), senderState(origPkt->senderState)
     {
     }
@@ -551,9 +564,6 @@ class Packet : public FastAlloc
     /** If there isn't data in the packet, allocate some. */
     void allocate();
 
-    /** Do the packet modify the same addresses. */
-    bool intersect(PacketPtr p);
-
     /**
      * Check a functional request against a memory value represented
      * by a base/size pair and an associated data array.  If the