mem: Unify delayed packet deletion
authorAndreas Hansson <andreas.hansson@arm.com>
Fri, 6 Nov 2015 08:26:21 +0000 (03:26 -0500)
committerAndreas Hansson <andreas.hansson@arm.com>
Fri, 6 Nov 2015 08:26:21 +0000 (03:26 -0500)
This patch unifies how we deal with delayed packet deletion, where the
receiving slave is responsible for deleting the packet, but the
sending agent (e.g. a cache) is still relying on the pointer until the
call to sendTimingReq completes. Previously we used a mix of a
deletion vector and a construct using unique_ptr. With this patch we
ensure all slaves use the latter approach.

12 files changed:
src/mem/cache/cache.cc
src/mem/cache/cache.hh
src/mem/coherent_xbar.cc
src/mem/coherent_xbar.hh
src/mem/dram_ctrl.cc
src/mem/dram_ctrl.hh
src/mem/dramsim2.cc
src/mem/dramsim2.hh
src/mem/simple_mem.cc
src/mem/simple_mem.hh
src/mem/tport.cc
src/mem/tport.hh

index 3e5ed42bc9340fe3a026e7353045c9115a723e19..aa95d56041458e1982e6bcd374ce817c5ae0082a 100644 (file)
@@ -542,15 +542,6 @@ bool
 Cache::recvTimingReq(PacketPtr pkt)
 {
     DPRINTF(CacheTags, "%s tags: %s\n", __func__, tags->print());
-//@todo Add back in MemDebug Calls
-//    MemDebug::cacheAccess(pkt);
-
-
-    /// @todo temporary hack to deal with memory corruption issue until
-    /// 4-phase transactions are complete
-    for (int x = 0; x < pendingDelete.size(); x++)
-        delete pendingDelete[x];
-    pendingDelete.clear();
 
     assert(pkt->isRequest());
 
@@ -602,10 +593,9 @@ Cache::recvTimingReq(PacketPtr pkt)
             // main memory will delete the packet
         }
 
-        /// @todo nominally we should just delete the packet here,
-        /// however, until 4-phase stuff we can't because sending
-        /// cache is still relying on it.
-        pendingDelete.push_back(pkt);
+        // queue for deletion, as the sending cache is still relying
+        // on the packet
+        pendingDelete.reset(pkt);
 
         // no need to take any action in this particular cache as the
         // caches along the path to memory are allowed to keep lines
@@ -678,12 +668,11 @@ Cache::recvTimingReq(PacketPtr pkt)
             // by access(), that calls accessBlock() function.
             cpuSidePort->schedTimingResp(pkt, request_time);
         } else {
-            /// @todo nominally we should just delete the packet here,
-            /// however, until 4-phase stuff we can't because sending cache is
-            /// still relying on it. If the block is found in access(),
-            /// CleanEvict and Writeback messages will be deleted here as
-            /// well.
-            pendingDelete.push_back(pkt);
+            // queue the packet for deletion, as the sending cache is
+            // still relying on it; if the block is found in access(),
+            // CleanEvict and Writeback messages will be deleted
+            // here as well
+            pendingDelete.reset(pkt);
         }
     } else {
         // miss
@@ -754,7 +743,7 @@ Cache::recvTimingReq(PacketPtr pkt)
                 // CleanEvicts corresponding to blocks which have outstanding
                 // requests in MSHRs can be deleted here.
                 if (pkt->cmd == MemCmd::CleanEvict) {
-                    pendingDelete.push_back(pkt);
+                    pendingDelete.reset(pkt);
                 } else {
                     DPRINTF(Cache, "%s coalescing MSHR for %s addr %#llx size %d\n",
                             __func__, pkt->cmdString(), pkt->getAddr(),
index ec436201b8e7993069a76a6e2662876e3e430b17..ae9e7e694bf3ed98f7f62c597fa9d3e1b4a9522f 100644 (file)
@@ -195,11 +195,10 @@ class Cache : public BaseCache
     const bool prefetchOnAccess;
 
     /**
-     * @todo this is a temporary workaround until the 4-phase code is committed.
-     * upstream caches need this packet until true is returned, so hold it for
-     * deletion until a subsequent call
+     * Upstream caches need this packet until true is returned, so
+     * hold it for deletion until a subsequent call
      */
-    std::vector<PacketPtr> pendingDelete;
+    std::unique_ptr<Packet> pendingDelete;
 
     /**
      * Does all the processing necessary to perform the provided request.
index 6a0136ea8d4b562fc050b71d1163910d16cafb2f..223ab6ab5d0126a4d85e8b31df4726e3a1b3c68d 100644 (file)
@@ -140,12 +140,6 @@ CoherentXBar::init()
 bool
 CoherentXBar::recvTimingReq(PacketPtr pkt, PortID slave_port_id)
 {
-    // @todo temporary hack to deal with memory corruption issue until
-    // 4-phase transactions are complete
-    for (int x = 0; x < pendingDelete.size(); x++)
-        delete pendingDelete[x];
-    pendingDelete.clear();
-
     // determine the source port based on the id
     SlavePort *src_port = slavePorts[slave_port_id];
 
@@ -223,7 +217,10 @@ CoherentXBar::recvTimingReq(PacketPtr pkt, PortID slave_port_id)
 
         // update the layer state and schedule an idle event
         reqLayers[master_port_id]->succeededTiming(packetFinishTime);
-        pendingDelete.push_back(pkt);
+
+        // queue the packet for deletion
+        pendingDelete.reset(pkt);
+
         return true;
     }
 
index e99e9374fa27679db982df6e56a485bb04795c3f..24d00628b2ccf670a25b0e607ea9899f8e304c21 100644 (file)
@@ -274,11 +274,10 @@ class CoherentXBar : public BaseXBar
     const Cycles snoopResponseLatency;
 
     /**
-     * @todo this is a temporary workaround until the 4-phase code is committed.
-     * upstream caches need this packet until true is returned, so hold it for
-     * deletion until a subsequent call
+     * Upstream caches need this packet until true is returned, so
+     * hold it for deletion until a subsequent call
      */
-    std::vector<PacketPtr> pendingDelete;
+    std::unique_ptr<Packet> pendingDelete;
 
     /** Function called by the port when the crossbar is recieving a Timing
       request packet.*/
index 3ba4616f788af5ccc18d8703127bc99875e84285..4bd83f761c2082b7d365fc3ae318716cae8badf1 100644 (file)
@@ -586,12 +586,6 @@ DRAMCtrl::printQs() const {
 bool
 DRAMCtrl::recvTimingReq(PacketPtr pkt)
 {
-    /// @todo temporary hack to deal with memory corruption issues until
-    /// 4-phase transactions are complete
-    for (int x = 0; x < pendingDelete.size(); x++)
-        delete pendingDelete[x];
-    pendingDelete.clear();
-
     // This is where we enter from the outside world
     DPRINTF(DRAM, "recvTimingReq: request %s addr %lld size %d\n",
             pkt->cmdString(), pkt->getAddr(), pkt->getSize());
@@ -600,7 +594,7 @@ DRAMCtrl::recvTimingReq(PacketPtr pkt)
     if (pkt->memInhibitAsserted() ||
         pkt->cmd == MemCmd::CleanEvict) {
         DPRINTF(DRAM, "Inhibited packet or clean evict -- Dropping it now\n");
-        pendingDelete.push_back(pkt);
+        pendingDelete.reset(pkt);
         return true;
     }
 
@@ -872,7 +866,7 @@ DRAMCtrl::accessAndRespond(PacketPtr pkt, Tick static_latency)
     } else {
         // @todo the packet is going to be deleted, and the DRAMPacket
         // is still having a pointer to it
-        pendingDelete.push_back(pkt);
+        pendingDelete.reset(pkt);
     }
 
     DPRINTF(DRAM, "Done\n");
index 617c94914cf6275959b71ecc627f63b3955b496d..6cd72b266a76f415e0fc30574d7efb4b23024882 100644 (file)
@@ -836,11 +836,11 @@ class DRAMCtrl : public AbstractMemory
     // timestamp offset
     uint64_t timeStampOffset;
 
-    /** @todo this is a temporary workaround until the 4-phase code is
-     * committed. upstream caches needs this packet until true is returned, so
-     * hold onto it for deletion until a subsequent call
+    /**
+     * Upstream caches need this packet until true is returned, so
+     * hold it for deletion until a subsequent call
      */
-    std::vector<PacketPtr> pendingDelete;
+    std::unique_ptr<Packet> pendingDelete;
 
     /**
      * This function increments the energy when called. If stats are
index 64acc5b573cd394dbb3a168c7623dd441e85e99c..cd0f45b23bdd1ced96463d7a2a219dac1e24d304 100644 (file)
@@ -178,16 +178,10 @@ DRAMSim2::recvTimingReq(PacketPtr pkt)
     // we should never see a new request while in retry
     assert(!retryReq);
 
-    // @todo temporary hack to deal with memory corruption issues until
-    // 4-phase transactions are complete
-    for (int x = 0; x < pendingDelete.size(); x++)
-        delete pendingDelete[x];
-    pendingDelete.clear();
-
     if (pkt->memInhibitAsserted()) {
         // snooper will supply based on copy of packet
         // still target's responsibility to delete packet
-        pendingDelete.push_back(pkt);
+        pendingDelete.reset(pkt);
         return true;
     }
 
@@ -281,9 +275,8 @@ DRAMSim2::accessAndRespond(PacketPtr pkt)
         if (!retryResp && !sendResponseEvent.scheduled())
             schedule(sendResponseEvent, time);
     } else {
-        // @todo the packet is going to be deleted, and the DRAMPacket
-        // is still having a pointer to it
-        pendingDelete.push_back(pkt);
+        // queue the packet for deletion
+        pendingDelete.reset(pkt);
     }
 }
 
index e57479247ca3cc89ba3acf5caed16b14001aab03..5cde19cd87af59e2810f75e4239ba22413faaba8 100644 (file)
@@ -160,11 +160,11 @@ class DRAMSim2 : public AbstractMemory
      */
     EventWrapper<DRAMSim2, &DRAMSim2::tick> tickEvent;
 
-    /** @todo this is a temporary workaround until the 4-phase code is
-     * committed. upstream caches needs this packet until true is returned, so
-     * hold onto it for deletion until a subsequent call
+    /**
+     * Upstream caches need this packet until true is returned, so
+     * hold it for deletion until a subsequent call
      */
-    std::vector<PacketPtr> pendingDelete;
+    std::unique_ptr<Packet> pendingDelete;
 
   public:
 
index f68066e75a2d0fb0ab7d5f1916b5f96482b6b8d4..7e350feb6a6d6ee606243b416097293f1adf5c5d 100644 (file)
@@ -97,16 +97,10 @@ SimpleMemory::recvFunctional(PacketPtr pkt)
 bool
 SimpleMemory::recvTimingReq(PacketPtr pkt)
 {
-    /// @todo temporary hack to deal with memory corruption issues until
-    /// 4-phase transactions are complete
-    for (int x = 0; x < pendingDelete.size(); x++)
-        delete pendingDelete[x];
-    pendingDelete.clear();
-
     if (pkt->memInhibitAsserted()) {
         // snooper will supply based on copy of packet
         // still target's responsibility to delete packet
-        pendingDelete.push_back(pkt);
+        pendingDelete.reset(pkt);
         return true;
     }
 
@@ -165,7 +159,7 @@ SimpleMemory::recvTimingReq(PacketPtr pkt)
         if (!retryResp && !dequeueEvent.scheduled())
             schedule(dequeueEvent, packetQueue.back().tick);
     } else {
-        pendingDelete.push_back(pkt);
+        pendingDelete.reset(pkt);
     }
 
     return true;
index 35d8aeafba48d60ef258a9cc0d6a4c4515e56610..d19de7608ff836ea46bede1a16f2bd0f5176d074 100644 (file)
@@ -175,11 +175,11 @@ class SimpleMemory : public AbstractMemory
      */
     Tick getLatency() const;
 
-    /** @todo this is a temporary workaround until the 4-phase code is
-     * committed. upstream caches needs this packet until true is returned, so
-     * hold onto it for deletion until a subsequent call
+    /**
+     * Upstream caches need this packet until true is returned, so
+     * hold it for deletion until a subsequent call
      */
-    std::vector<PacketPtr> pendingDelete;
+    std::unique_ptr<Packet> pendingDelete;
 
   public:
 
index aa783ada020f36d122ce253343568fcdfd8099c9..9f9403a22ecdc560dd6ca6f4230ee955ff0827ad 100644 (file)
@@ -62,12 +62,6 @@ SimpleTimingPort::recvFunctional(PacketPtr pkt)
 bool
 SimpleTimingPort::recvTimingReq(PacketPtr pkt)
 {
-    /// @todo temporary hack to deal with memory corruption issue until
-    /// 4-phase transactions are complete. Remove me later
-    for (int x = 0; x < pendingDelete.size(); x++)
-        delete pendingDelete[x];
-    pendingDelete.clear();
-
     // the SimpleTimingPort should not be used anywhere where there is
     // a need to deal with inhibited packets
     if (pkt->memInhibitAsserted())
@@ -82,10 +76,8 @@ SimpleTimingPort::recvTimingReq(PacketPtr pkt)
         assert(pkt->isResponse());
         schedTimingResp(pkt, curTick() + latency);
     } else {
-        /// @todo nominally we should just delete the packet here.
-        /// Until 4-phase stuff we can't because the sending
-        /// cache is still relying on it
-        pendingDelete.push_back(pkt);
+        // queue the packet for deletion
+        pendingDelete.reset(pkt);
     }
 
     return true;
index 166a23125b09a10d3eb0a3d0a94b19de4ec015b9..d7e4bbc74a00310cae81717cbd4b09885177a405 100644 (file)
@@ -81,12 +81,10 @@ class SimpleTimingPort : public QueuedSlavePort
     virtual Tick recvAtomic(PacketPtr pkt) = 0;
 
     /**
-     * @todo this is a temporary workaround until the 4-phase code is committed.
-     * upstream caches need this packet until true is returned, so hold it for
-     * deletion until a subsequent call
+     * Upstream caches need this packet until true is returned, so
+     * hold it for deletion until a subsequent call
      */
-    std::vector<PacketPtr> pendingDelete;
-
+    std::unique_ptr<Packet> pendingDelete;
 
   public: