diff --git a/src/mem/cache/base.cc b/src/mem/cache/base.cc
index 0187703..a1fd151 100644
--- a/src/mem/cache/base.cc
+++ b/src/mem/cache/base.cc
@@ -844,11 +844,11 @@
 
     // The compressor is called to compress the updated data, so that its
     // metadata can be updated.
-    std::size_t compression_size = 0;
     Cycles compression_lat = Cycles(0);
     Cycles decompression_lat = Cycles(0);
-    compressor->compress(data, compression_lat, decompression_lat,
-                         compression_size);
+    const auto comp_data =
+        compressor->compress(data, compression_lat, decompression_lat);
+    std::size_t compression_size = comp_data->getSizeBits();
 
     // If block's compression factor increased, it may not be co-allocatable
     // anymore. If so, some blocks might need to be evicted to make room for
@@ -1421,8 +1421,9 @@
     // calculate the amount of extra cycles needed to read or write compressed
     // blocks.
     if (compressor && pkt->hasData()) {
-        compressor->compress(pkt->getConstPtr<uint64_t>(), compression_lat,
-                             decompression_lat, blk_size_bits);
+        const auto comp_data = compressor->compress(
+            pkt->getConstPtr<uint64_t>(), compression_lat, decompression_lat);
+        blk_size_bits = comp_data->getSizeBits();
     }
 
     // Find replacement victim
diff --git a/src/mem/cache/compressors/Compressors.py b/src/mem/cache/compressors/Compressors.py
index 46050f6..1c47ac1 100644
--- a/src/mem/cache/compressors/Compressors.py
+++ b/src/mem/cache/compressors/Compressors.py
@@ -35,6 +35,8 @@
     cxx_header = "mem/cache/compressors/base.hh"
 
     block_size = Param.Int(Parent.cache_line_size, "Block size in bytes")
+    chunk_size_bits = Param.Unsigned(32,
+        "Size of a parsing data chunk (in bits)")
     size_threshold = Param.Unsigned(Parent.cache_line_size, "Minimum size, "
         "in bytes, in which a block must be compressed to. Otherwise it is "
         "stored in its uncompressed state")
@@ -53,31 +55,43 @@
     cxx_class = 'Compressor::Base64Delta8'
     cxx_header = "mem/cache/compressors/base_delta.hh"
 
+    chunk_size_bits = 64
+
 class Base64Delta16(BaseDictionaryCompressor):
     type = 'Base64Delta16'
     cxx_class = 'Compressor::Base64Delta16'
     cxx_header = "mem/cache/compressors/base_delta.hh"
 
+    chunk_size_bits = 64
+
 class Base64Delta32(BaseDictionaryCompressor):
     type = 'Base64Delta32'
     cxx_class = 'Compressor::Base64Delta32'
     cxx_header = "mem/cache/compressors/base_delta.hh"
 
+    chunk_size_bits = 64
+
 class Base32Delta8(BaseDictionaryCompressor):
     type = 'Base32Delta8'
     cxx_class = 'Compressor::Base32Delta8'
     cxx_header = "mem/cache/compressors/base_delta.hh"
 
+    chunk_size_bits = 32
+
 class Base32Delta16(BaseDictionaryCompressor):
     type = 'Base32Delta16'
     cxx_class = 'Compressor::Base32Delta16'
     cxx_header = "mem/cache/compressors/base_delta.hh"
 
+    chunk_size_bits = 32
+
 class Base16Delta8(BaseDictionaryCompressor):
     type = 'Base16Delta8'
     cxx_class = 'Compressor::Base16Delta8'
     cxx_header = "mem/cache/compressors/base_delta.hh"
 
+    chunk_size_bits = 16
+
 class CPack(BaseDictionaryCompressor):
     type = 'CPack'
     cxx_class = 'Compressor::CPack'
@@ -105,6 +119,7 @@
     cxx_class = 'Compressor::Perfect'
     cxx_header = "mem/cache/compressors/perfect.hh"
 
+    chunk_size_bits = 64
     max_compression_ratio = Param.Int(2,
         "Maximum compression ratio allowed")
     compression_latency = Param.Cycles(1,
@@ -117,11 +132,15 @@
     cxx_class = 'Compressor::RepeatedQwords'
     cxx_header = "mem/cache/compressors/repeated_qwords.hh"
 
+    chunk_size_bits = 64
+
 class ZeroCompressor(BaseDictionaryCompressor):
     type = 'ZeroCompressor'
     cxx_class = 'Compressor::Zero'
     cxx_header = "mem/cache/compressors/zero.hh"
 
+    chunk_size_bits = 64
+
 class BDI(MultiCompressor):
     compressors = [ZeroCompressor(), RepeatedQwordsCompressor(),
         Base64Delta8(), Base64Delta16(), Base64Delta32(), Base32Delta8(),
diff --git a/src/mem/cache/compressors/base.cc b/src/mem/cache/compressors/base.cc
index f8fda81..de29c69 100644
--- a/src/mem/cache/compressors/base.cc
+++ b/src/mem/cache/compressors/base.cc
@@ -33,6 +33,7 @@
 #include "mem/cache/compressors/base.hh"
 
 #include <algorithm>
+#include <climits>
 #include <cmath>
 #include <cstdint>
 #include <string>
@@ -75,19 +76,58 @@
 }
 
 Base::Base(const Params *p)
-  : SimObject(p), blkSize(p->block_size), sizeThreshold(p->size_threshold),
+  : SimObject(p), blkSize(p->block_size), chunkSizeBits(p->chunk_size_bits),
+    sizeThreshold(p->size_threshold),
     stats(*this)
 {
+    fatal_if(64 % chunkSizeBits,
+        "64 must be a multiple of the chunk granularity.");
+
     fatal_if(blkSize < sizeThreshold, "Compressed data must fit in a block");
 }
 
+std::vector<Base::Chunk>
+Base::toChunks(const uint64_t* data) const
+{
+    // Number of chunks in a 64-bit value
+    const unsigned num_chunks_per_64 =
+        (sizeof(uint64_t) * CHAR_BIT) / chunkSizeBits;
+
+    // Turn a 64-bit array into a chunkSizeBits-array
+    std::vector<Chunk> chunks((blkSize * CHAR_BIT) / chunkSizeBits, 0);
+    for (int i = 0; i < chunks.size(); i++) {
+        const int index_64 = std::floor(i / (double)num_chunks_per_64);
+        const unsigned start = i % num_chunks_per_64;
+        chunks[i] = bits(data[index_64],
+            (start + 1) * chunkSizeBits - 1, start * chunkSizeBits);
+    }
+
+    return chunks;
+}
+
 void
-Base::compress(const uint64_t* data, Cycles& comp_lat,
-                              Cycles& decomp_lat, std::size_t& comp_size_bits)
+Base::fromChunks(const std::vector<Chunk>& chunks, uint64_t* data) const
+{
+    // Number of chunks in a 64-bit value
+    const unsigned num_chunks_per_64 =
+        (sizeof(uint64_t) * CHAR_BIT) / chunkSizeBits;
+
+    // Turn a chunkSizeBits-array into a 64-bit array
+    std::memset(data, 0, blkSize);
+    for (int i = 0; i < chunks.size(); i++) {
+        const int index_64 = std::floor(i / (double)num_chunks_per_64);
+        const unsigned start = i % num_chunks_per_64;
+        replaceBits(data[index_64], (start + 1) * chunkSizeBits - 1,
+            start * chunkSizeBits, chunks[i]);
+    }
+}
+
+std::unique_ptr<Base::CompressionData>
+Base::compress(const uint64_t* data, Cycles& comp_lat, Cycles& decomp_lat)
 {
     // Apply compression
     std::unique_ptr<CompressionData> comp_data =
-        compress(data, comp_lat, decomp_lat);
+        compress(toChunks(data), comp_lat, decomp_lat);
 
     // If we are in debug mode apply decompression just after the compression.
     // If the results do not match, we've got an error
@@ -104,9 +144,10 @@
 
     // Get compression size. If compressed size is greater than the size
     // threshold, the compression is seen as unsuccessful
-    comp_size_bits = comp_data->getSizeBits();
-    if (comp_size_bits >= sizeThreshold * 8) {
-        comp_size_bits = blkSize * 8;
+    std::size_t comp_size_bits = comp_data->getSizeBits();
+    if (comp_size_bits > sizeThreshold * CHAR_BIT) {
+        comp_size_bits = blkSize * CHAR_BIT;
+        comp_data->setSizeBits(comp_size_bits);
     }
 
     // Update stats
@@ -118,6 +159,8 @@
     DPRINTF(CacheComp, "Compressed cache line from %d to %d bits. " \
             "Compression latency: %llu, decompression latency: %llu\n",
             blkSize*8, comp_size_bits, comp_lat, decomp_lat);
+
+    return std::move(comp_data);
 }
 
 Cycles
diff --git a/src/mem/cache/compressors/base.hh b/src/mem/cache/compressors/base.hh
index 87cb0fc..1008aae 100644
--- a/src/mem/cache/compressors/base.hh
+++ b/src/mem/cache/compressors/base.hh
@@ -50,27 +50,45 @@
 /**
  * Base cache compressor interface. Every cache compressor must implement a
  * compression and a decompression method.
+ *
+ * Compressors usually cannot parse all data input at once. Therefore, they
+ * typically divide the input into multiple *chunks*, and parse them one at
+ * a cycle.
  */
 class Base : public SimObject
 {
+  public:
+    /**
+     * Forward declaration of compression data. Every new compressor must
+     * create a new compression data based on it.
+     */
+    class CompressionData;
+
   protected:
     /**
+     * A chunk is a basic lexical unit. The data being compressed is received
+     * by the compressor as a raw pointer. In order to parse this data, the
+     * compressor must divide it into smaller units. Typically, state-of-the-
+     * art compressors interpret cache lines as sequential 32-bit chunks
+     * (chunks), but any size is valid.
+     * @sa chunkSizeBits
+     */
+    typedef uint64_t Chunk;
+
+    /**
      * This compressor must be able to access the protected functions of
      * its sub-compressors.
      */
     friend class Multi;
 
     /**
-     * Forward declaration of compression data. Every new compressor must
-     * create a new compression data based on it.
-     */
-    class CompressionData;
-
-    /**
      * Uncompressed cache line size (in bytes).
      */
     const std::size_t blkSize;
 
+    /** Chunk size, in number of bits. */
+    const unsigned chunkSizeBits;
+
     /**
      * Size in bytes at which a compression is classified as bad and therefore
      * the compressed block is restored to its uncompressed format.
@@ -102,19 +120,37 @@
     } stats;
 
     /**
+     * This function splits the raw data into chunks, so that it can be
+     * parsed by the compressor.
+     *
+     * @param data The raw pointer to the data being compressed.
+     * @return The raw data divided into a vector of sequential chunks.
+     */
+    std::vector<Chunk> toChunks(const uint64_t* data) const;
+
+    /**
+     * This function re-joins the chunks to recreate the original data.
+     *
+     * @param chunks The raw data divided into a vector of sequential chunks.
+     * @param data The raw pointer to the data.
+     */
+    void fromChunks(const std::vector<Chunk>& chunks, uint64_t* data) const;
+
+    /**
      * Apply the compression process to the cache line.
      * Returns the number of cycles used by the compressor, however it is
      * usually covered by a good pipelined execution, and is currently ignored.
      * The decompression latency is also returned, in order to avoid
      * increasing simulation time and memory consumption.
      *
-     * @param cache_line The cache line to be compressed.
+     * @param chunks The cache line to be compressed, divided into chunks.
      * @param comp_lat Compression latency in number of cycles.
      * @param decomp_lat Decompression latency in number of cycles.
      * @return Cache line after compression.
      */
     virtual std::unique_ptr<CompressionData> compress(
-        const uint64_t* cache_line, Cycles& comp_lat, Cycles& decomp_lat) = 0;
+        const std::vector<Chunk>& chunks, Cycles& comp_lat,
+        Cycles& decomp_lat) = 0;
 
     /**
      * Apply the decompression process to the compressed data.
@@ -137,10 +173,10 @@
      * @param data The cache line to be compressed.
      * @param comp_lat Compression latency in number of cycles.
      * @param decomp_lat Decompression latency in number of cycles.
-     * @param comp_size_bits Compressed data size (in bits).
+     * @return Cache line after compression.
      */
-    void compress(const uint64_t* data, Cycles& comp_lat,
-                  Cycles& decomp_lat, std::size_t& comp_size_bits);
+    std::unique_ptr<CompressionData>
+    compress(const uint64_t* data, Cycles& comp_lat, Cycles& decomp_lat);
 
     /**
      * Get the decompression latency if the block is compressed. Latency is 0
diff --git a/src/mem/cache/compressors/base_delta.hh b/src/mem/cache/compressors/base_delta.hh
index 1e4b70e..929b8d1 100644
--- a/src/mem/cache/compressors/base_delta.hh
+++ b/src/mem/cache/compressors/base_delta.hh
@@ -115,9 +115,9 @@
 
     void addToDictionary(DictionaryEntry data) override;
 
-    std::unique_ptr<Base::CompressionData>
-    compress(const uint64_t* data, Cycles& comp_lat,
-        Cycles& decomp_lat) override;
+    std::unique_ptr<Base::CompressionData> compress(
+        const std::vector<Base::Chunk>& chunks,
+        Cycles& comp_lat, Cycles& decomp_lat) override;
 
   public:
     typedef BaseDictionaryCompressorParams Params;
diff --git a/src/mem/cache/compressors/base_delta_impl.hh b/src/mem/cache/compressors/base_delta_impl.hh
index 97ab1cf..46d62db 100644
--- a/src/mem/cache/compressors/base_delta_impl.hh
+++ b/src/mem/cache/compressors/base_delta_impl.hh
@@ -67,11 +67,12 @@
 
 template <class BaseType, std::size_t DeltaSizeBits>
 std::unique_ptr<Base::CompressionData>
-BaseDelta<BaseType, DeltaSizeBits>::compress(const uint64_t* data,
-    Cycles& comp_lat, Cycles& decomp_lat)
+BaseDelta<BaseType, DeltaSizeBits>::compress(
+    const std::vector<Base::Chunk>& chunks, Cycles& comp_lat,
+    Cycles& decomp_lat)
 {
     std::unique_ptr<Base::CompressionData> comp_data =
-        DictionaryCompressor<BaseType>::compress(data);
+        DictionaryCompressor<BaseType>::compress(chunks);
 
     // If there are more bases than the maximum, the compressor failed.
     // Otherwise, we have to take into account all bases that have not
diff --git a/src/mem/cache/compressors/cpack.cc b/src/mem/cache/compressors/cpack.cc
index 40e983a..4ba8c84 100644
--- a/src/mem/cache/compressors/cpack.cc
+++ b/src/mem/cache/compressors/cpack.cc
@@ -50,10 +50,11 @@
 }
 
 std::unique_ptr<Base::CompressionData>
-CPack::compress(const uint64_t* data, Cycles& comp_lat, Cycles& decomp_lat)
+CPack::compress(const std::vector<Chunk>& chunks,
+    Cycles& comp_lat, Cycles& decomp_lat)
 {
     std::unique_ptr<Base::CompressionData> comp_data =
-        DictionaryCompressor<uint32_t>::compress(data);
+        DictionaryCompressor<uint32_t>::compress(chunks);
 
     // Set compression latency (Accounts for pattern matching, length
     // generation, packaging and shifting)
diff --git a/src/mem/cache/compressors/cpack.hh b/src/mem/cache/compressors/cpack.hh
index 2925b54..a6d3e21 100644
--- a/src/mem/cache/compressors/cpack.hh
+++ b/src/mem/cache/compressors/cpack.hh
@@ -98,16 +98,9 @@
 
     void addToDictionary(DictionaryEntry data) override;
 
-    /**
-     * Apply compression.
-     *
-     * @param data The cache line to be compressed.
-     * @param comp_lat Compression latency in number of cycles.
-     * @param decomp_lat Decompression latency in number of cycles.
-     * @return Cache line after compression.
-     */
     std::unique_ptr<Base::CompressionData> compress(
-        const uint64_t* data, Cycles& comp_lat, Cycles& decomp_lat) override;
+        const std::vector<Base::Chunk>& chunks,
+        Cycles& comp_lat, Cycles& decomp_lat) override;
 
   public:
     /** Convenience typedef. */
diff --git a/src/mem/cache/compressors/dictionary_compressor.hh b/src/mem/cache/compressors/dictionary_compressor.hh
index a0bdf4d..873843c 100644
--- a/src/mem/cache/compressors/dictionary_compressor.hh
+++ b/src/mem/cache/compressors/dictionary_compressor.hh
@@ -232,10 +232,11 @@
     /**
      * Apply compression.
      *
-     * @param data The cache line to be compressed.
+     * @param chunks The cache line to be compressed.
      * @return Cache line after compression.
      */
-    std::unique_ptr<Base::CompressionData> compress(const uint64_t* data);
+    std::unique_ptr<Base::CompressionData> compress(
+        const std::vector<Chunk>& chunks);
 
     using BaseDictionaryCompressor::compress;
 
diff --git a/src/mem/cache/compressors/dictionary_compressor_impl.hh b/src/mem/cache/compressors/dictionary_compressor_impl.hh
index b157216..11495a3 100644
--- a/src/mem/cache/compressors/dictionary_compressor_impl.hh
+++ b/src/mem/cache/compressors/dictionary_compressor_impl.hh
@@ -123,7 +123,7 @@
 
 template <class T>
 std::unique_ptr<Base::CompressionData>
-DictionaryCompressor<T>::compress(const uint64_t* data)
+DictionaryCompressor<T>::compress(const std::vector<Chunk>& chunks)
 {
     std::unique_ptr<Base::CompressionData> comp_data =
         instantiateDictionaryCompData();
@@ -133,8 +133,7 @@
 
     // Compress every value sequentially
     CompData* const comp_data_ptr = static_cast<CompData*>(comp_data.get());
-    const std::vector<T> values((T*)data, (T*)data + blkSize / sizeof(T));
-    for (const auto& value : values) {
+    for (const auto& value : chunks) {
         std::unique_ptr<Pattern> pattern = compressValue(value);
         DPRINTF(CacheComp, "Compressed %016x to %s\n", value,
             pattern->print());
diff --git a/src/mem/cache/compressors/fpcd.cc b/src/mem/cache/compressors/fpcd.cc
index ba46379..fb22e7b 100644
--- a/src/mem/cache/compressors/fpcd.cc
+++ b/src/mem/cache/compressors/fpcd.cc
@@ -55,10 +55,11 @@
 }
 
 std::unique_ptr<Base::CompressionData>
-FPCD::compress(const uint64_t* data, Cycles& comp_lat, Cycles& decomp_lat)
+FPCD::compress(const std::vector<Chunk>& chunks,
+    Cycles& comp_lat, Cycles& decomp_lat)
 {
     std::unique_ptr<Base::CompressionData> comp_data =
-        DictionaryCompressor<uint32_t>::compress(data);
+        DictionaryCompressor<uint32_t>::compress(chunks);
 
     // Set compression latency (Accounts for zero checks, ones check, match
     // previous check, match penultimate check, repeated values check, pattern
diff --git a/src/mem/cache/compressors/fpcd.hh b/src/mem/cache/compressors/fpcd.hh
index 8aed461..6d8f459 100644
--- a/src/mem/cache/compressors/fpcd.hh
+++ b/src/mem/cache/compressors/fpcd.hh
@@ -140,7 +140,8 @@
     void addToDictionary(DictionaryEntry data) override;
 
     std::unique_ptr<Base::CompressionData> compress(
-        const uint64_t* data, Cycles& comp_lat, Cycles& decomp_lat) override;
+        const std::vector<Base::Chunk>& chunks,
+        Cycles& comp_lat, Cycles& decomp_lat) override;
 
   public:
     typedef FPCDParams Params;
diff --git a/src/mem/cache/compressors/multi.cc b/src/mem/cache/compressors/multi.cc
index 229c3b9..51dbc2b 100644
--- a/src/mem/cache/compressors/multi.cc
+++ b/src/mem/cache/compressors/multi.cc
@@ -72,7 +72,7 @@
 }
 
 std::unique_ptr<Base::CompressionData>
-Multi::compress(const uint64_t* cache_line, Cycles& comp_lat,
+Multi::compress(const std::vector<Chunk>& chunks, Cycles& comp_lat,
     Cycles& decomp_lat)
 {
     struct Results
@@ -114,6 +114,12 @@
         }
     };
 
+    // Each sub-compressor can have its own chunk size; therefore, revert
+    // the chunks to raw data, so that they handle the conversion internally
+    uint64_t data[blkSize / sizeof(uint64_t)];
+    std::memset(data, 0, blkSize);
+    fromChunks(chunks, data);
+
     // Find the ranking of the compressor outputs
     std::priority_queue<std::shared_ptr<Results>,
         std::vector<std::shared_ptr<Results>>, ResultsComparator> results;
@@ -121,7 +127,7 @@
     for (unsigned i = 0; i < compressors.size(); i++) {
         Cycles temp_decomp_lat;
         auto temp_comp_data =
-            compressors[i]->compress(cache_line, comp_lat, temp_decomp_lat);
+            compressors[i]->compress(data, comp_lat, temp_decomp_lat);
         results.push(std::make_shared<Results>(i, std::move(temp_comp_data),
             temp_decomp_lat, blkSize));
         max_comp_lat = std::max(max_comp_lat, comp_lat);
diff --git a/src/mem/cache/compressors/multi.hh b/src/mem/cache/compressors/multi.hh
index 06af978..095dd03 100644
--- a/src/mem/cache/compressors/multi.hh
+++ b/src/mem/cache/compressors/multi.hh
@@ -78,7 +78,8 @@
     ~Multi();
 
     std::unique_ptr<Base::CompressionData> compress(
-        const uint64_t* data, Cycles& comp_lat, Cycles& decomp_lat) override;
+        const std::vector<Base::Chunk>& chunks,
+        Cycles& comp_lat, Cycles& decomp_lat) override;
 
     void decompress(const CompressionData* comp_data, uint64_t* data) override;
 };
diff --git a/src/mem/cache/compressors/perfect.cc b/src/mem/cache/compressors/perfect.cc
index 41a7e6d..58c4b0e 100644
--- a/src/mem/cache/compressors/perfect.cc
+++ b/src/mem/cache/compressors/perfect.cc
@@ -40,27 +40,19 @@
 
 namespace Compressor {
 
-Perfect::CompData::CompData(const uint64_t* data,
-    std::size_t num_entries)
-    : CompressionData(), entries(data, data + num_entries)
-{
-}
-
 Perfect::Perfect(const Params *p)
-    : Base(p),
-      compressedSize(8 * blkSize / p->max_compression_ratio),
-      compressionLatency(p->compression_latency),
-      decompressionLatency(p->decompression_latency)
+  : Base(p), compressedSize(8 * blkSize / p->max_compression_ratio),
+    compressionLatency(p->compression_latency),
+    decompressionLatency(p->decompression_latency)
 {
 }
 
 std::unique_ptr<Base::CompressionData>
-Perfect::compress(const uint64_t* cache_line, Cycles& comp_lat,
-    Cycles& decomp_lat)
+Perfect::compress(const std::vector<Chunk>& chunks,
+    Cycles& comp_lat, Cycles& decomp_lat)
 {
     // Compress every word sequentially
-    std::unique_ptr<Base::CompressionData> comp_data(
-        new CompData(cache_line, blkSize/8));
+    std::unique_ptr<Base::CompressionData> comp_data(new CompData(chunks));
 
     // Set relevant metadata
     comp_data->setSizeBits(compressedSize);
@@ -75,10 +67,7 @@
     uint64_t* data)
 {
     // Decompress every entry sequentially
-    const std::vector<uint64_t>& entries =
-        static_cast<const CompData*>(comp_data)->entries;
-    assert(entries.size() == (blkSize/8));
-    std::copy(entries.begin(), entries.end(), data);
+    fromChunks(static_cast<const CompData*>(comp_data)->chunks, data);
 }
 
 } // namespace Compressor
diff --git a/src/mem/cache/compressors/perfect.hh b/src/mem/cache/compressors/perfect.hh
index e279ec6..eccba6a 100644
--- a/src/mem/cache/compressors/perfect.hh
+++ b/src/mem/cache/compressors/perfect.hh
@@ -59,8 +59,9 @@
     /** Number of cycles needed to perform decompression. */
     const Cycles decompressionLatency;
 
-    std::unique_ptr<CompressionData> compress(const uint64_t* cache_line,
-        Cycles& comp_lat, Cycles& decomp_lat) override;
+    std::unique_ptr<CompressionData> compress(
+        const std::vector<Chunk>& chunks, Cycles& comp_lat,
+        Cycles& decomp_lat) override;
 
     void decompress(const CompressionData* comp_data, uint64_t* data) override;
 
@@ -74,15 +75,17 @@
 {
   public:
     /** The original data is simply copied over to this vector. */
-    std::vector<uint64_t> entries;
+    std::vector<Chunk> chunks;
 
     /**
      * Default constructor that creates a copy of the original data.
      *
-     * @param data The data to be compressed.
-     * @param num_entries The number of qwords in the data.
+     * @param chunks The data to be compressed.
      */
-    CompData(const uint64_t* data, std::size_t num_entries);
+    CompData(const std::vector<Chunk>& chunks)
+      : CompressionData(), chunks(chunks)
+    {
+    }
     ~CompData() = default;
 };
 
diff --git a/src/mem/cache/compressors/repeated_qwords.cc b/src/mem/cache/compressors/repeated_qwords.cc
index db19b26..1840a64 100644
--- a/src/mem/cache/compressors/repeated_qwords.cc
+++ b/src/mem/cache/compressors/repeated_qwords.cc
@@ -53,11 +53,11 @@
 }
 
 std::unique_ptr<Base::CompressionData>
-RepeatedQwords::compress(const uint64_t* data, Cycles& comp_lat,
-    Cycles& decomp_lat)
+RepeatedQwords::compress(const std::vector<Chunk>& chunks,
+    Cycles& comp_lat, Cycles& decomp_lat)
 {
     std::unique_ptr<Base::CompressionData> comp_data =
-        DictionaryCompressor::compress(data);
+        DictionaryCompressor::compress(chunks);
 
     // Since there is a single value repeated over and over, there should be
     // a single dictionary entry. If there are more, the compressor failed
diff --git a/src/mem/cache/compressors/repeated_qwords.hh b/src/mem/cache/compressors/repeated_qwords.hh
index 9a2df3c..31edd6e 100644
--- a/src/mem/cache/compressors/repeated_qwords.hh
+++ b/src/mem/cache/compressors/repeated_qwords.hh
@@ -92,7 +92,8 @@
     void addToDictionary(DictionaryEntry data) override;
 
     std::unique_ptr<Base::CompressionData> compress(
-        const uint64_t* data, Cycles& comp_lat, Cycles& decomp_lat) override;
+        const std::vector<Base::Chunk>& chunks,
+        Cycles& comp_lat, Cycles& decomp_lat) override;
 
   public:
     typedef RepeatedQwordsCompressorParams Params;
diff --git a/src/mem/cache/compressors/zero.cc b/src/mem/cache/compressors/zero.cc
index db80679..d5e0199 100644
--- a/src/mem/cache/compressors/zero.cc
+++ b/src/mem/cache/compressors/zero.cc
@@ -53,11 +53,11 @@
 }
 
 std::unique_ptr<Base::CompressionData>
-Zero::compress(const uint64_t* data, Cycles& comp_lat,
+Zero::compress(const std::vector<Chunk>& chunks, Cycles& comp_lat,
     Cycles& decomp_lat)
 {
     std::unique_ptr<Base::CompressionData> comp_data =
-        DictionaryCompressor::compress(data);
+        DictionaryCompressor::compress(chunks);
 
     // If there is any non-zero entry, the compressor failed
     if (numEntries > 0) {
diff --git a/src/mem/cache/compressors/zero.hh b/src/mem/cache/compressors/zero.hh
index f45a639..57a2685 100644
--- a/src/mem/cache/compressors/zero.hh
+++ b/src/mem/cache/compressors/zero.hh
@@ -92,7 +92,8 @@
     void addToDictionary(DictionaryEntry data) override;
 
     std::unique_ptr<Base::CompressionData> compress(
-        const uint64_t* data, Cycles& comp_lat, Cycles& decomp_lat) override;
+        const std::vector<Base::Chunk>& chunks,
+        Cycles& comp_lat, Cycles& decomp_lat) override;
 
   public:
     typedef ZeroCompressorParams Params;