mem: Assume all dynamic packet data is array allocated

This patch simplifies how we deal with dynamically allocated data in
the packet, always assuming that it is array allocated, and hence
should be array deallocated (delete[] as opposed to delete). The only
uses of dataDynamic was in the Ruby testers.

The ARRAY_DATA flag in the packet is removed accordingly. No
defragmentation of the flags is done at this point, leaving a gap in
the bit masks.

As the last part the patch, it renames dataDynamicArray to dataDynamic.

diff --git a/src/cpu/minor/lsq.cc b/src/cpu/minor/lsq.cc
index fca58008500de7240c335d7915678d9fad44095a..75dbb804aff05993c77a14c9f4d080dd60d32bd2 100644 (file)
--- a/src/cpu/minor/lsq.cc
+++ b/src/cpu/minor/lsq.cc
@@ -1558,7 +1558,7 @@ makePacketForRequest(Request &request, bool isLoad,
     if (isLoad)
         ret->allocate();
     else
-        ret->dataDynamicArray(data);
+        ret->dataDynamic(data);
 
     return ret;
 }

diff --git a/src/cpu/o3/fetch_impl.hh b/src/cpu/o3/fetch_impl.hh
index 47a64a9bff5e18943ae8bd4d945be83b60c059f1..d3b0b3ac583ddde46655a917e81e3619bde59e8b 100644 (file)
--- a/src/cpu/o3/fetch_impl.hh
+++ b/src/cpu/o3/fetch_impl.hh
@@ -669,7 +669,7 @@ DefaultFetch<Impl>::finishTranslation(const Fault &fault, RequestPtr mem_req)
 
         // Build packet here.
         PacketPtr data_pkt = new Packet(mem_req, MemCmd::ReadReq);
-        data_pkt->dataDynamicArray(new uint8_t[fetchBufferSize]);
+        data_pkt->dataDynamic(new uint8_t[fetchBufferSize]);
 
         fetchBufferPC[tid] = fetchBufferBlockPC;
         fetchBufferValid[tid] = false;

diff --git a/src/cpu/simple/timing.cc b/src/cpu/simple/timing.cc
index 2d0ab330e4e26545f4895c5eeccb6abdf158be94..c2bcdee6318a572ed13b5679a14229235b34cb15 100644 (file)
--- a/src/cpu/simple/timing.cc
+++ b/src/cpu/simple/timing.cc
@@ -271,7 +271,7 @@ TimingSimpleCPU::sendData(RequestPtr req, uint8_t *data, uint64_t *res,
 {
     PacketPtr pkt;
     buildPacket(pkt, req, read);
-    pkt->dataDynamicArray<uint8_t>(data);
+    pkt->dataDynamic<uint8_t>(data);
     if (req->getFlags().isSet(Request::NO_ACCESS)) {
         assert(!dcache_pkt);
         pkt->makeResponse();
@@ -379,7 +379,7 @@ TimingSimpleCPU::buildSplitPacket(PacketPtr &pkt1, PacketPtr &pkt2,
     req->setPhys(req1->getPaddr(), req->getSize(), req1->getFlags(), dataMasterId());
     PacketPtr pkt = new Packet(req, pkt1->cmd.responseCommand());
 
-    pkt->dataDynamicArray<uint8_t>(data);
+    pkt->dataDynamic<uint8_t>(data);
     pkt1->dataStatic<uint8_t>(data);
     pkt2->dataStatic<uint8_t>(data + req1->getSize());
 

diff --git a/src/cpu/testers/directedtest/InvalidateGenerator.cc b/src/cpu/testers/directedtest/InvalidateGenerator.cc
index 84a90844fc6c657432d5facfde2a5aeb3b8dc1bf..61c3f59727b09ad85e309393b7d8fbec56370943 100644 (file)
--- a/src/cpu/testers/directedtest/InvalidateGenerator.cc
+++ b/src/cpu/testers/directedtest/InvalidateGenerator.cc
@@ -76,9 +76,7 @@ InvalidateGenerator::initiate()
     } else {
         panic("initiate was unexpectedly called\n");
     }
-    uint8_t* dummyData = new uint8_t;
-    *dummyData = 0;
-    pkt->dataDynamic(dummyData);
+    pkt->allocate();
 
     if (port->sendTimingReq(pkt)) {
         DPRINTF(DirectedTest, "initiating request - successful\n");

diff --git a/src/cpu/testers/directedtest/SeriesRequestGenerator.cc b/src/cpu/testers/directedtest/SeriesRequestGenerator.cc
index 80523280b2105bf213e716e4a252192d27ca0e9e..2356fb47a5d3ecf59acb90d03f42fd560f9dd630 100644 (file)
--- a/src/cpu/testers/directedtest/SeriesRequestGenerator.cc
+++ b/src/cpu/testers/directedtest/SeriesRequestGenerator.cc
@@ -69,9 +69,7 @@ SeriesRequestGenerator::initiate()
     }
 
     PacketPtr pkt = new Packet(req, cmd);
-    uint8_t* dummyData = new uint8_t;
-    *dummyData = 0;
-    pkt->dataDynamic(dummyData);
+    pkt->allocate();
 
     if (port->sendTimingReq(pkt)) {
         DPRINTF(DirectedTest, "initiating request - successful\n");

diff --git a/src/cpu/testers/memtest/memtest.cc b/src/cpu/testers/memtest/memtest.cc
index 082737f8ada0bcaead50102a51bd827374059f2f..53c01b7f79312f9f658d85b1dafb1832fa449d4f 100644 (file)
--- a/src/cpu/testers/memtest/memtest.cc
+++ b/src/cpu/testers/memtest/memtest.cc
@@ -327,7 +327,7 @@ MemTest::tick()
                 blockAddr(req->getPaddr()), *result);
 
         PacketPtr pkt = new Packet(req, MemCmd::ReadReq);
-        pkt->dataDynamicArray(new uint8_t[req->getSize()]);
+        pkt->dataDynamic(new uint8_t[req->getSize()]);
         MemTestSenderState *state = new MemTestSenderState(result);
         pkt->senderState = state;
 
@@ -349,7 +349,7 @@ MemTest::tick()
 
         PacketPtr pkt = new Packet(req, MemCmd::WriteReq);
         uint8_t *pkt_data = new uint8_t[req->getSize()];
-        pkt->dataDynamicArray(pkt_data);
+        pkt->dataDynamic(pkt_data);
         memcpy(pkt_data, &data, req->getSize());
         MemTestSenderState *state = new MemTestSenderState(result);
         pkt->senderState = state;

diff --git a/src/cpu/testers/networktest/networktest.cc b/src/cpu/testers/networktest/networktest.cc
index 94dedf648de2b86c79da04381a4f3d929a264072..8ad32d140eeb09df2e7cacc616d5248f71fa79c3 100644 (file)
--- a/src/cpu/testers/networktest/networktest.cc
+++ b/src/cpu/testers/networktest/networktest.cc
@@ -261,7 +261,7 @@ NetworkTest::generatePkt()
             destination, req->getPaddr());
 
     PacketPtr pkt = new Packet(req, requestType);
-    pkt->dataDynamicArray(new uint8_t[req->getSize()]);
+    pkt->dataDynamic(new uint8_t[req->getSize()]);
     pkt->senderState = NULL;
 
     sendPkt(pkt);

diff --git a/src/cpu/testers/rubytest/Check.cc b/src/cpu/testers/rubytest/Check.cc
index 19d0623c04dee9174d4b84c962f1dce978732f9d..b320ca61dd574044be2904b0121081596f7cff49 100644 (file)
--- a/src/cpu/testers/rubytest/Check.cc
+++ b/src/cpu/testers/rubytest/Check.cc
@@ -113,7 +113,7 @@ Check::initiatePrefetch()
     // despite the oddity of the 0 size (questionable if this should
     // even be allowed), a prefetch is still a read and as such needs
     // a place to store the result
-    uint8_t *data = new uint8_t;
+    uint8_t *data = new uint8_t[1];
     pkt->dataDynamic(data);
 
     // push the subblock onto the sender state.  The sequencer will
@@ -192,7 +192,7 @@ Check::initiateAction()
     // }
 
     PacketPtr pkt = new Packet(req, cmd);
-    uint8_t *writeData = new uint8_t;
+    uint8_t *writeData = new uint8_t[1];
     *writeData = m_value + m_store_count;
     pkt->dataDynamic(writeData);
 
@@ -246,7 +246,7 @@ Check::initiateCheck()
     req->setThreadContext(index, 0);
     PacketPtr pkt = new Packet(req, MemCmd::ReadReq);
     uint8_t *dataArray = new uint8_t[CHECK_SIZE];
-    pkt->dataDynamicArray(dataArray);
+    pkt->dataDynamic(dataArray);
 
     // push the subblock onto the sender state.  The sequencer will
     // update the subblock on the return

diff --git a/src/cpu/testers/traffic_gen/generators.cc b/src/cpu/testers/traffic_gen/generators.cc
index 5e19384bcb4825cd04ca6f2e2ec73ed08d78ca0f..f0cf14206ce2ae106e3800c2212cd26ae9194e6a 100644 (file)
--- a/src/cpu/testers/traffic_gen/generators.cc
+++ b/src/cpu/testers/traffic_gen/generators.cc
@@ -62,7 +62,7 @@ BaseGen::getPacket(Addr addr, unsigned size, const MemCmd& cmd,
     PacketPtr pkt = new Packet(req, cmd);
 
     uint8_t* pkt_data = new uint8_t[req->getSize()];
-    pkt->dataDynamicArray(pkt_data);
+    pkt->dataDynamic(pkt_data);
 
     if (cmd.isWrite()) {
         memset(pkt_data, 0xA, req->getSize());

diff --git a/src/mem/packet.hh b/src/mem/packet.hh
index e8fb00680829760e1c0a4278f352a72e22d61958..19423db589fde00f75f268948b1483fd6db88574 100644 (file)
--- a/src/mem/packet.hh
+++ b/src/mem/packet.hh
@@ -247,11 +247,9 @@ class Packet : public Printable
     /// when the packet is destroyed?
     static const FlagsType STATIC_DATA            = 0x00001000;
     /// The data pointer points to a value that should be freed when
-    /// the packet is destroyed.
+    /// the packet is destroyed. The pointer is assumed to be pointing
+    /// to an array, and delete [] is consequently called
     static const FlagsType DYNAMIC_DATA           = 0x00002000;
-    /// the data pointer points to an array (thus delete []) needs to
-    /// be called on it rather than simply delete.
-    static const FlagsType ARRAY_DATA             = 0x00004000;
     /// suppress the error if this packet encounters a functional
     /// access failure.
     static const FlagsType SUPPRESS_FUNC_ERROR    = 0x00008000;
@@ -813,7 +811,7 @@ class Packet : public Printable
     void
     dataStatic(T *p)
     {
-        assert(flags.noneSet(STATIC_DATA|DYNAMIC_DATA|ARRAY_DATA));
+        assert(flags.noneSet(STATIC_DATA|DYNAMIC_DATA));
         data = (PacketDataPtr)p;
         flags.set(STATIC_DATA);
     }
@@ -830,7 +828,7 @@ class Packet : public Printable
     void
     dataStaticConst(const T *p)
     {
-        assert(flags.noneSet(STATIC_DATA|DYNAMIC_DATA|ARRAY_DATA));
+        assert(flags.noneSet(STATIC_DATA|DYNAMIC_DATA));
         data = const_cast<PacketDataPtr>(p);
         flags.set(STATIC_DATA);
     }
@@ -841,22 +839,9 @@ class Packet : public Printable
      */
     template <typename T>
     void
-    dataDynamicArray(T *p)
-    {
-        assert(flags.noneSet(STATIC_DATA|DYNAMIC_DATA|ARRAY_DATA));
-        data = (PacketDataPtr)p;
-        flags.set(DYNAMIC_DATA|ARRAY_DATA);
-    }
-
-    /**
-     * set the data pointer to a value that should have delete called
-     * on it.
-     */
-    template <typename T>
-    void
     dataDynamic(T *p)
     {
-        assert(flags.noneSet(STATIC_DATA|DYNAMIC_DATA|ARRAY_DATA));
+        assert(flags.noneSet(STATIC_DATA|DYNAMIC_DATA));
         data = (PacketDataPtr)p;
         flags.set(DYNAMIC_DATA);
     }
@@ -938,12 +923,10 @@ class Packet : public Printable
     void
     deleteData()
     {
-        if (flags.isSet(ARRAY_DATA))
+        if (flags.isSet(DYNAMIC_DATA))
             delete [] data;
-        else if (flags.isSet(DYNAMIC_DATA))
-            delete data;
 
-        flags.clear(STATIC_DATA|DYNAMIC_DATA|ARRAY_DATA);
+        flags.clear(STATIC_DATA|DYNAMIC_DATA);
         data = NULL;
     }
 
@@ -952,7 +935,7 @@ class Packet : public Printable
     allocate()
     {
         assert(flags.noneSet(STATIC_DATA|DYNAMIC_DATA));
-        flags.set(DYNAMIC_DATA|ARRAY_DATA);
+        flags.set(DYNAMIC_DATA);
         data = new uint8_t[getSize()];
     }