mem: Add const getters for write packet data

This patch takes a first step in tightening up how we use the data
pointer in write packets. A const getter is added for the pointer
itself (getConstPtr), and a number of member functions are also made
const accordingly. In a range of places throughout the memory system
the new member is used.

The patch also removes the unused isReadWrite function.

diff --git a/src/cpu/inorder/resources/cache_unit.cc b/src/cpu/inorder/resources/cache_unit.cc
index 251369e01cfd83fbd644bfe8fef925ea4e55f899..3a44986e2090db67c22362c14cf637ea33ebdeec 100644 (file)
--- a/src/cpu/inorder/resources/cache_unit.cc
+++ b/src/cpu/inorder/resources/cache_unit.cc
@@ -68,7 +68,7 @@ using namespace ThePipeline;
 
 #if TRACING_ON
 static std::string
-printMemData(uint8_t *data, unsigned size)
+printMemData(const uint8_t *data, unsigned size)
 {
     std::stringstream dataStr;
     for (unsigned pos = 0; pos < size; pos++) {
@@ -855,7 +855,7 @@ CacheUnit::doCacheAccess(DynInstPtr inst, uint64_t *write_res,
          DPRINTF(InOrderCachePort,
                  "[tid:%u]: [sn:%i]: Storing data: %s\n",
                  tid, inst->seqNum,
-                 printMemData(cache_req->dataPkt->getPtr<uint8_t>(),
+                 printMemData(cache_req->dataPkt->getConstPtr<uint8_t>(),
                               cache_req->dataPkt->getSize()));
 
         if (mem_req->isCondSwap()) {
@@ -1061,9 +1061,9 @@ CacheUnit::processCacheCompletion(PacketPtr pkt)
         DPRINTF(InOrderCachePort,
                 "[tid:%u]: [sn:%i]: Bytes loaded were: %s\n",
                 tid, inst->seqNum,
-                (split_pkt) ? printMemData(split_pkt->getPtr<uint8_t>(),
+                (split_pkt) ? printMemData(split_pkt->getConstPtr<uint8_t>(),
                                            split_pkt->getSize()) :
-                              printMemData(cache_pkt->getPtr<uint8_t>(),
+                              printMemData(cache_pkt->getConstPtr<uint8_t>(),
                                            cache_pkt->getSize()));
     } else if(inst->isStore()) {
         assert(cache_pkt->isWrite());
@@ -1071,9 +1071,9 @@ CacheUnit::processCacheCompletion(PacketPtr pkt)
         DPRINTF(InOrderCachePort,
                 "[tid:%u]: [sn:%i]: Bytes stored were: %s\n",
                 tid, inst->seqNum,
-                (split_pkt) ? printMemData(split_pkt->getPtr<uint8_t>(),
+                (split_pkt) ? printMemData(split_pkt->getConstPtr<uint8_t>(),
                                            split_pkt->getSize()) :
-                              printMemData(cache_pkt->getPtr<uint8_t>(),
+                              printMemData(cache_pkt->getConstPtr<uint8_t>(),
                                            cache_pkt->getSize()));
     }
 

diff --git a/src/cpu/inorder/resources/fetch_unit.cc b/src/cpu/inorder/resources/fetch_unit.cc
index 6892688b2828b83391ea405b628741ee4c43a419..13864e5894f414485ca174183c46b76b1877225f 100644 (file)
--- a/src/cpu/inorder/resources/fetch_unit.cc
+++ b/src/cpu/inorder/resources/fetch_unit.cc
@@ -503,7 +503,7 @@ FetchUnit::processCacheCompletion(PacketPtr pkt)
 
     // Copy Data to pendingFetch queue...
     (*pend_it)->block = new uint8_t[cacheBlkSize];
-    memcpy((*pend_it)->block, cache_pkt->getPtr<uint8_t>(), cacheBlkSize);
+    memcpy((*pend_it)->block, cache_pkt->getConstPtr<uint8_t>(), cacheBlkSize);
     (*pend_it)->valid = true;
 
     cache_req->setMemAccPending(false);

diff --git a/src/cpu/minor/execute.cc b/src/cpu/minor/execute.cc
index 123128358cf9cbcf7f2f18e8dc1ae9ad7afd91a5..69cb9a239fd4cc3676714a39feaa8646501782b2 100644 (file)
--- a/src/cpu/minor/execute.cc
+++ b/src/cpu/minor/execute.cc
@@ -355,7 +355,7 @@ Execute::handleMemResponse(MinorDynInstPtr inst,
 
         if (is_load && packet->getSize() > 0) {
             DPRINTF(MinorMem, "Memory data[0]: 0x%x\n",
-                static_cast<unsigned int>(packet->getPtr<uint8_t>()[0]));
+                static_cast<unsigned int>(packet->getConstPtr<uint8_t>()[0]));
         }
 
         /* Complete the memory access instruction */

diff --git a/src/cpu/minor/lsq.cc b/src/cpu/minor/lsq.cc
index cae0d36666bea16964a93437fa47ebc5ed9e5ed4..fca58008500de7240c335d7915678d9fad44095a 100644 (file)
--- a/src/cpu/minor/lsq.cc
+++ b/src/cpu/minor/lsq.cc
@@ -560,7 +560,7 @@ LSQ::SplitDataRequest::retireResponse(PacketPtr response)
              *  by the response fragment */
             std::memcpy(
                 data + (response->req->getVaddr() - request.getVaddr()),
-                response->getPtr<uint8_t>(),
+                response->getConstPtr<uint8_t>(),
                 response->req->getSize());
         }
     }

diff --git a/src/cpu/o3/fetch_impl.hh b/src/cpu/o3/fetch_impl.hh
index 1c9799e4157b6a0f10919f728a2a2a7c2247b746..47a64a9bff5e18943ae8bd4d945be83b60c059f1 100644 (file)
--- a/src/cpu/o3/fetch_impl.hh
+++ b/src/cpu/o3/fetch_impl.hh
@@ -388,7 +388,7 @@ DefaultFetch<Impl>::processCacheCompletion(PacketPtr pkt)
         return;
     }
 
-    memcpy(fetchBuffer[tid], pkt->getPtr<uint8_t>(), fetchBufferSize);
+    memcpy(fetchBuffer[tid], pkt->getConstPtr<uint8_t>(), fetchBufferSize);
     fetchBufferValid[tid] = true;
 
     // Wake up the CPU (if it went to sleep and was waiting on

diff --git a/src/cpu/simple/atomic.cc b/src/cpu/simple/atomic.cc
index 06969f3e3435cc1fd7d3dd48fa5d3155c2fbb15b..8dcae01c560a92b18f8cc0f6b334d1ac1ebf606f 100644 (file)
--- a/src/cpu/simple/atomic.cc
+++ b/src/cpu/simple/atomic.cc
@@ -469,7 +469,7 @@ AtomicSimpleCPU::writeMem(uint8_t *data, unsigned size,
 
                 if (req->isSwap()) {
                     assert(res);
-                    memcpy(res, pkt.getPtr<uint8_t>(), fullSize);
+                    memcpy(res, pkt.getConstPtr<uint8_t>(), fullSize);
                 }
             }
 

diff --git a/src/cpu/testers/memtest/memtest.cc b/src/cpu/testers/memtest/memtest.cc
index d949178c269be4a5bbfeb2b68e725e3db819e493..082737f8ada0bcaead50102a51bd827374059f2f 100644 (file)
--- a/src/cpu/testers/memtest/memtest.cc
+++ b/src/cpu/testers/memtest/memtest.cc
@@ -173,6 +173,7 @@ MemTest::completeRequest(PacketPtr pkt)
         safe_cast<MemTestSenderState *>(pkt->senderState);
 
     uint8_t *data = state->data;
+    // @todo: This should really be a const pointer
     uint8_t *pkt_data = pkt->getPtr<uint8_t>();
 
     //Remove the address from the list of outstanding

diff --git a/src/cpu/testers/rubytest/Check.cc b/src/cpu/testers/rubytest/Check.cc
index 9de766077caabb665f415148e60532965d0b7940..19d0623c04dee9174d4b84c962f1dce978732f9d 100644 (file)
--- a/src/cpu/testers/rubytest/Check.cc
+++ b/src/cpu/testers/rubytest/Check.cc
@@ -197,7 +197,7 @@ Check::initiateAction()
     pkt->dataDynamic(writeData);
 
     DPRINTF(RubyTest, "data 0x%x check 0x%x\n",
-            *(pkt->getPtr<uint8_t>()), *writeData);
+            *(pkt->getConstPtr<uint8_t>()), *writeData);
 
     // push the subblock onto the sender state.  The sequencer will
     // update the subblock on the return

diff --git a/src/mem/abstract_mem.cc b/src/mem/abstract_mem.cc
index c819ce2fc0edc055f21e3d301eb86439ada7f711..dca0403fb8488f8473afc35b9e2c49b0eb4aeb54 100644 (file)
--- a/src/mem/abstract_mem.cc
+++ b/src/mem/abstract_mem.cc
@@ -309,7 +309,7 @@ AbstractMemory::checkLockedAddrList(PacketPtr pkt)
                     A, system()->getMasterName(pkt->req->masterId()),          \
                     pkt->getSize(), pkt->getAddr(),                            \
                     pkt->req->isUncacheable() ? 'U' : 'C');                    \
-            DDUMP(MemoryAccess, pkt->getPtr<uint8_t>(), pkt->getSize());       \
+            DDUMP(MemoryAccess, pkt->getConstPtr<uint8_t>(), pkt->getSize());  \
         }                                                                      \
     } while (0)
 
@@ -344,7 +344,8 @@ AbstractMemory::access(PacketPtr pkt)
         bool overwrite_mem = true;
         // keep a copy of our possible write value, and copy what is at the
         // memory address into the packet
-        std::memcpy(&overwrite_val[0], pkt->getPtr<uint8_t>(), pkt->getSize());
+        std::memcpy(&overwrite_val[0], pkt->getConstPtr<uint8_t>(),
+                    pkt->getSize());
         std::memcpy(pkt->getPtr<uint8_t>(), hostAddr, pkt->getSize());
 
         if (pkt->req->isCondSwap()) {
@@ -381,7 +382,7 @@ AbstractMemory::access(PacketPtr pkt)
     } else if (pkt->isWrite()) {
         if (writeOK(pkt)) {
             if (pmemAddr) {
-                memcpy(hostAddr, pkt->getPtr<uint8_t>(), pkt->getSize());
+                memcpy(hostAddr, pkt->getConstPtr<uint8_t>(), pkt->getSize());
                 DPRINTF(MemoryAccess, "%s wrote %x bytes to address %x\n",
                         __func__, pkt->getSize(), pkt->getAddr());
             }
@@ -416,7 +417,7 @@ AbstractMemory::functionalAccess(PacketPtr pkt)
         pkt->makeResponse();
     } else if (pkt->isWrite()) {
         if (pmemAddr)
-            memcpy(hostAddr, pkt->getPtr<uint8_t>(), pkt->getSize());
+            memcpy(hostAddr, pkt->getConstPtr<uint8_t>(), pkt->getSize());
         TRACE_PACKET("Write");
         pkt->makeResponse();
     } else if (pkt->isPrint()) {

diff --git a/src/mem/cache/cache.hh b/src/mem/cache/cache.hh
index b9a9a7823ae3568f06bf975dec8ebc0eaecce89c..e0bd29752b903e224740708300c5e8d52fe96e38 100644 (file)
--- a/src/mem/cache/cache.hh
+++ b/src/mem/cache/cache.hh
@@ -287,7 +287,7 @@ class Cache : public BaseCache
                                bool pending_downgrade = false);
     bool satisfyMSHR(MSHR *mshr, PacketPtr pkt, BlkType *blk);
 
-    void doTimingSupplyResponse(PacketPtr req_pkt, uint8_t *blk_data,
+    void doTimingSupplyResponse(PacketPtr req_pkt, const uint8_t *blk_data,
                                 bool already_copied, bool pending_inval);
 
     /**

diff --git a/src/mem/cache/cache_impl.hh b/src/mem/cache/cache_impl.hh
index 66abf6eff90e05586c8bef5f89eb7b63851deb90..f4099c0ef437ffad849293cce4e8671ec02ce88e 100644 (file)
--- a/src/mem/cache/cache_impl.hh
+++ b/src/mem/cache/cache_impl.hh
@@ -357,7 +357,7 @@ Cache<TagStore>::access(PacketPtr pkt, BlkType *&blk,
             blk->status &= ~BlkWritable;
             ++fastWrites;
         }
-        std::memcpy(blk->data, pkt->getPtr<uint8_t>(), blkSize);
+        std::memcpy(blk->data, pkt->getConstPtr<uint8_t>(), blkSize);
         DPRINTF(Cache, "%s new state is %s\n", __func__, blk->print());
         incHitCount(pkt);
         return true;
@@ -1211,7 +1211,7 @@ Cache<TagStore>::recvTimingResp(PacketPtr pkt)
                 completion_time = clockEdge(responseLatency) +
                     pkt->lastWordDelay;
                 if (pkt->isRead() && !is_error) {
-                    target->pkt->setData(pkt->getPtr<uint8_t>());
+                    target->pkt->setData(pkt->getConstPtr<uint8_t>());
                 }
             }
             target->pkt->makeTimingResponse();
@@ -1535,7 +1535,7 @@ Cache<TagStore>::handleFill(PacketPtr pkt, BlkType *blk,
 
     // if we got new data, copy it in
     if (pkt->isRead()) {
-        std::memcpy(blk->data, pkt->getPtr<uint8_t>(), blkSize);
+        std::memcpy(blk->data, pkt->getConstPtr<uint8_t>(), blkSize);
     }
 
     blk->whenReady = clockEdge() + responseLatency * clockPeriod() +
@@ -1554,7 +1554,7 @@ Cache<TagStore>::handleFill(PacketPtr pkt, BlkType *blk,
 template<class TagStore>
 void
 Cache<TagStore>::
-doTimingSupplyResponse(PacketPtr req_pkt, uint8_t *blk_data,
+doTimingSupplyResponse(PacketPtr req_pkt, const uint8_t *blk_data,
                        bool already_copied, bool pending_inval)
 {
     // sanity check
@@ -1810,7 +1810,7 @@ Cache<TagStore>::recvTimingSnoopReq(PacketPtr pkt)
                 // the packet's invalidate flag is set...
                 assert(pkt->isInvalidate());
             }
-            doTimingSupplyResponse(pkt, wb_pkt->getPtr<uint8_t>(),
+            doTimingSupplyResponse(pkt, wb_pkt->getConstPtr<uint8_t>(),
                                    false, false);
 
             if (pkt->isInvalidate()) {
@@ -2020,7 +2020,7 @@ Cache<TagStore>::getTimingPacket()
             pkt = new Packet(tgt_pkt);
             pkt->allocate();
             if (pkt->isWrite()) {
-                pkt->setData(tgt_pkt->getPtr<uint8_t>());
+                pkt->setData(tgt_pkt->getConstPtr<uint8_t>());
             }
         }
     }

diff --git a/src/mem/external_slave.cc b/src/mem/external_slave.cc
index c2ec8e2e4cc65ce84474689f2e14d2e1f1b51181..67800b9a24aa62eb275b81d6177231805f18436e 100644 (file)
--- a/src/mem/external_slave.cc
+++ b/src/mem/external_slave.cc
@@ -108,7 +108,7 @@ StubSlavePort::recvAtomic(PacketPtr packet)
 
         DPRINTF(ExternalPort, "StubSlavePort: recvAtomic a: 0x%x size: %d"
             " data: ...\n", packet->getAddr(), size);
-        DDUMP(ExternalPort, packet->getPtr<uint8_t>(), size);
+        DDUMP(ExternalPort, packet->getConstPtr<uint8_t>(), size);
     }
 
     return 0;

diff --git a/src/mem/packet.cc b/src/mem/packet.cc
index 8bbd7ff18e1bd3452c3138a064c6b4bef7985160..9dd67746b291aa59dc2241f40087a001a9571fbd 100644 (file)
--- a/src/mem/packet.cc
+++ b/src/mem/packet.cc
@@ -303,11 +303,11 @@ Packet::checkFunctional(Printable *obj, Addr addr, bool is_secure, int size,
         }
     } else if (isWrite()) {
         if (offset >= 0) {
-            memcpy(data + offset, getPtr<uint8_t>(),
+            memcpy(data + offset, getConstPtr<uint8_t>(),
                    (min(func_end, val_end) - func_start) + 1);
         } else {
             // val_start > func_start
-            memcpy(data, getPtr<uint8_t>() - offset,
+            memcpy(data, getConstPtr<uint8_t>() - offset,
                    (min(func_end, val_end) - val_start) + 1);
         }
     } else {

diff --git a/src/mem/packet.hh b/src/mem/packet.hh
index 8d84a7ccbfea119c135ef8ff4b04522f67de7f2e..fea9dbaae0c4925398f307c5ca69466b5368e725 100644 (file)
--- a/src/mem/packet.hh
+++ b/src/mem/packet.hh
@@ -186,7 +186,6 @@ class MemCmd
     bool needsResponse() const  { return testCmdAttrib(NeedsResponse); }
     bool isInvalidate() const   { return testCmdAttrib(IsInvalidate); }
     bool hasData() const        { return testCmdAttrib(HasData); }
-    bool isReadWrite() const    { return isRead() && isWrite(); }
     bool isLLSC() const         { return testCmdAttrib(IsLlsc); }
     bool isSWPrefetch() const   { return testCmdAttrib(IsSWPrefetch); }
     bool isHWPrefetch() const   { return testCmdAttrib(IsHWPrefetch); }
@@ -501,7 +500,6 @@ class Packet : public Printable
     bool needsResponse() const  { return cmd.needsResponse(); }
     bool isInvalidate() const   { return cmd.isInvalidate(); }
     bool hasData() const        { return cmd.hasData(); }
-    bool isReadWrite() const    { return cmd.isReadWrite(); }
     bool isLLSC() const         { return cmd.isLLSC(); }
     bool isError() const        { return cmd.isError(); }
     bool isPrint() const        { return cmd.isPrint(); }
@@ -852,11 +850,19 @@ class Packet : public Printable
         return (T*)data;
     }
 
+    template <typename T>
+    const T*
+    getConstPtr() const
+    {
+        assert(flags.isSet(STATIC_DATA|DYNAMIC_DATA));
+        return (const T*)data;
+    }
+
     /**
      * return the value of what is pointed to in the packet.
      */
     template <typename T>
-    T get();
+    T get() const;
 
     /**
      * set the value in the data pointer to v.
@@ -868,7 +874,7 @@ class Packet : public Printable
      * Copy data into the packet from the provided pointer.
      */
     void
-    setData(uint8_t *p)
+    setData(const uint8_t *p)
     {
         if (p != getPtr<uint8_t>())
             std::memcpy(getPtr<uint8_t>(), p, getSize());
@@ -879,7 +885,7 @@ class Packet : public Printable
      * which is aligned to the given block size.
      */
     void
-    setDataFromBlock(uint8_t *blk_data, int blkSize)
+    setDataFromBlock(const uint8_t *blk_data, int blkSize)
     {
         setData(blk_data + getOffset(blkSize));
     }
@@ -889,16 +895,16 @@ class Packet : public Printable
      * is aligned to the given block size.
      */
     void
-    writeData(uint8_t *p)
+    writeData(uint8_t *p) const
     {
-        std::memcpy(p, getPtr<uint8_t>(), getSize());
+        std::memcpy(p, getConstPtr<uint8_t>(), getSize());
     }
 
     /**
      * Copy data from the packet to the memory at the provided pointer.
      */
     void
-    writeDataToBlock(uint8_t *blk_data, int blkSize)
+    writeDataToBlock(uint8_t *blk_data, int blkSize) const
     {
         writeData(blk_data + getOffset(blkSize));
     }

diff --git a/src/mem/packet_access.hh b/src/mem/packet_access.hh
index fca9606fc84a73273a4a3e54f96c9d8e0dedd98d..9e6f1cbb1a304b77c1847a3ce8142c5365b5235d 100644 (file)
--- a/src/mem/packet_access.hh
+++ b/src/mem/packet_access.hh
@@ -45,7 +45,7 @@
 /** return the value of what is pointed to in the packet. */
 template <typename T>
 inline T
-Packet::get()
+Packet::get() const
 {
     assert(flags.isSet(STATIC_DATA|DYNAMIC_DATA));
     assert(sizeof(T) <= size);

diff --git a/src/mem/ruby/common/DataBlock.cc b/src/mem/ruby/common/DataBlock.cc
index c71449dd028426b5ec46f3f375f4d458aab9ede7..2a292444aebb3adb8cd0c4198d1b22caad4f2eb5 100644 (file)
--- a/src/mem/ruby/common/DataBlock.cc
+++ b/src/mem/ruby/common/DataBlock.cc
@@ -78,7 +78,7 @@ DataBlock::getData(int offset, int len) const
 }
 
 void
-DataBlock::setData(uint8_t *data, int offset, int len)
+DataBlock::setData(const uint8_t *data, int offset, int len)
 {
     assert(offset + len <= RubySystem::getBlockSizeBytes());
     memcpy(&m_data[offset], data, len);

diff --git a/src/mem/ruby/common/DataBlock.hh b/src/mem/ruby/common/DataBlock.hh
index 56320523b6cdd4d1b995c9bda790d68ffdd4c23c..ac08fac82517408cbc8119b6e860215492e6ba27 100644 (file)
--- a/src/mem/ruby/common/DataBlock.hh
+++ b/src/mem/ruby/common/DataBlock.hh
@@ -59,7 +59,7 @@ class DataBlock
     uint8_t getByte(int whichByte) const;
     const uint8_t *getData(int offset, int len) const;
     void setByte(int whichByte, uint8_t data);
-    void setData(uint8_t *data, int offset, int len);
+    void setData(const uint8_t *data, int offset, int len);
     void copyPartial(const DataBlock & dblk, int offset, int len);
     bool equal(const DataBlock& obj) const;
     void print(std::ostream& out) const;

diff --git a/src/mem/ruby/slicc_interface/RubyRequest.cc b/src/mem/ruby/slicc_interface/RubyRequest.cc
index ff90e415e2a3334e4925ab1ba6fa08f682556331..e2f275006a5651041cc9b88ced052fedab2ad694 100644 (file)
--- a/src/mem/ruby/slicc_interface/RubyRequest.cc
+++ b/src/mem/ruby/slicc_interface/RubyRequest.cc
@@ -72,7 +72,7 @@ RubyRequest::functionalWrite(Packet *pkt)
     Addr mBase = m_PhysicalAddress.getAddress();
     Addr mTail = mBase + m_Size;
 
-    uint8_t * pktData = pkt->getPtr<uint8_t>();
+    const uint8_t * pktData = pkt->getConstPtr<uint8_t>();
 
     Addr cBase = std::max(wBase, mBase);
     Addr cTail = std::min(wTail, mTail);

diff --git a/src/mem/ruby/slicc_interface/RubySlicc_Util.hh b/src/mem/ruby/slicc_interface/RubySlicc_Util.hh
index 8e2a1c5b16cce227394326950b7da12c9968623a..dd9a1f2a4821047ea5c9a9c4a8b272932c98b7a4 100644 (file)
--- a/src/mem/ruby/slicc_interface/RubySlicc_Util.hh
+++ b/src/mem/ruby/slicc_interface/RubySlicc_Util.hh
@@ -135,7 +135,7 @@ testAndWrite(Address addr, DataBlock& blk, Packet *pkt)
     lineAddr.makeLineAddress();
 
     if (pktLineAddr == lineAddr) {
-        uint8_t *data = pkt->getPtr<uint8_t>();
+        const uint8_t *data = pkt->getConstPtr<uint8_t>();
         unsigned int size_in_bytes = pkt->getSize();
         unsigned startByte = pkt->getAddr() - lineAddr.getAddress();
 

diff --git a/src/mem/ruby/system/Sequencer.cc b/src/mem/ruby/system/Sequencer.cc
index 281ea22bef29e53ee77d1a3458c6000e32694e91..ef1b9676b35082f97d445488ae38322023a186c4 100644 (file)
--- a/src/mem/ruby/system/Sequencer.cc
+++ b/src/mem/ruby/system/Sequencer.cc
@@ -526,7 +526,7 @@ Sequencer::hitCallback(SequencerRequest* srequest, DataBlock& data,
 
     // update the data unless it is a non-data-carrying flush
     if (g_system_ptr->m_warmup_enabled) {
-        data.setData(pkt->getPtr<uint8_t>(),
+        data.setData(pkt->getConstPtr<uint8_t>(),
                      request_address.getOffset(), pkt->getSize());
     } else if (!pkt->isFlush()) {
         if ((type == RubyRequestType_LD) ||
@@ -538,7 +538,7 @@ Sequencer::hitCallback(SequencerRequest* srequest, DataBlock& data,
                    data.getData(request_address.getOffset(), pkt->getSize()),
                    pkt->getSize());
         } else {
-            data.setData(pkt->getPtr<uint8_t>(),
+            data.setData(pkt->getConstPtr<uint8_t>(),
                          request_address.getOffset(), pkt->getSize());
         }
     }