mem-cache: Use Packet functions to write data blocks

Instead of using raw memcpy, use the proper writer functions
from the Packet class in Cache.

Fixed typos in comments of these functions.

Change-Id: I156a00989c6cbaa73763349006a37a18243d6ed4
Reviewed-on: https://gem5-review.googlesource.com/9661
Reviewed-by: Jason Lowe-Power <jason@lowepower.com>
Reviewed-by: Nikos Nikoleris <nikos.nikoleris@arm.com>
Maintainer: Nikos Nikoleris <nikos.nikoleris@arm.com>

diff --git a/src/mem/cache/cache.cc b/src/mem/cache/cache.cc
index c03b5b2a8064b392e6bf1a8f1cf9f508e9c4b66d..28c4343d1ae2db779c6ead41aa3f0e1624b7f6de 100644 (file)
--- a/src/mem/cache/cache.cc
+++ b/src/mem/cache/cache.cc
@@ -416,7 +416,7 @@ Cache::access(PacketPtr pkt, CacheBlk *&blk, Cycles &lat,
         }
         // nothing else to do; writeback doesn't expect response
         assert(!pkt->needsResponse());
-        std::memcpy(blk->data, pkt->getConstPtr<uint8_t>(), blkSize);
+        pkt->writeDataToBlock(blk->data, blkSize);
         DPRINTF(Cache, "%s new state is %s\n", __func__, blk->print());
         incHitCount(pkt);
         // populate the time when the block will be ready to access.
@@ -477,7 +477,7 @@ Cache::access(PacketPtr pkt, CacheBlk *&blk, Cycles &lat,
         }
         // nothing else to do; writeback doesn't expect response
         assert(!pkt->needsResponse());
-        std::memcpy(blk->data, pkt->getConstPtr<uint8_t>(), blkSize);
+        pkt->writeDataToBlock(blk->data, blkSize);
         DPRINTF(Cache, "%s new state is %s\n", __func__, blk->print());
 
         incHitCount(pkt);
@@ -1684,7 +1684,7 @@ Cache::writebackBlk(CacheBlk *blk)
     blk->status &= ~BlkDirty;
 
     pkt->allocate();
-    std::memcpy(pkt->getPtr<uint8_t>(), blk->data, blkSize);
+    pkt->setDataFromBlock(blk->data, blkSize);
 
     return pkt;
 }
@@ -1722,7 +1722,7 @@ Cache::writecleanBlk(CacheBlk *blk, Request::Flags dest, PacketId id)
     blk->status &= ~BlkDirty;
 
     pkt->allocate();
-    std::memcpy(pkt->getPtr<uint8_t>(), blk->data, blkSize);
+    pkt->setDataFromBlock(blk->data, blkSize);
 
     return pkt;
 }
@@ -1970,7 +1970,7 @@ Cache::handleFill(PacketPtr pkt, CacheBlk *blk, PacketList &writebacks,
         assert(pkt->hasData());
         assert(pkt->getSize() == blkSize);
 
-        std::memcpy(blk->data, pkt->getConstPtr<uint8_t>(), blkSize);
+        pkt->writeDataToBlock(blk->data, blkSize);
     }
     // We pay for fillLatency here.
     blk->whenReady = clockEdge() + fillLatency * clockPeriod() +

diff --git a/src/mem/packet.hh b/src/mem/packet.hh
index 66625b382013972f25255b07e8271e7614c51fa1..b5b882c91c64f0af769a82035afa91ba838ac828 100644 (file)
--- a/src/mem/packet.hh
+++ b/src/mem/packet.hh
@@ -324,10 +324,10 @@ class Packet : public Printable
 
   private:
    /**
-    * A pointer to the data being transfered.  It can be differnt
-    * sizes at each level of the heirarchy so it belongs in the
+    * A pointer to the data being transferred. It can be different
+    * sizes at each level of the hierarchy so it belongs to the
     * packet, not request. This may or may not be populated when a
-    * responder recieves the packet. If not populated it memory should
+    * responder receives the packet. If not populated memory should
     * be allocated.
     */
     PacketDataPtr data;
@@ -1096,8 +1096,8 @@ class Packet : public Printable
     }
 
     /**
-     * Copy data from the packet to the provided block pointer, which
-     * is aligned to the given block size.
+     * Copy data from the packet to the memory at the provided pointer.
+     * @param p Pointer to which data will be copied.
      */
     void
     writeData(uint8_t *p) const
@@ -1106,7 +1106,10 @@ class Packet : public Printable
     }
 
     /**
-     * Copy data from the packet to the memory at the provided pointer.
+     * Copy data from the packet to the provided block pointer, which
+     * is aligned to the given block size.
+     * @param blk_data Pointer to block to which data will be copied.
+     * @param blkSize Block size in bytes.
      */
     void
     writeDataToBlock(uint8_t *blk_data, int blkSize) const