diff --git a/src/mem/cache/compressors/cpack.hh b/src/mem/cache/compressors/cpack.hh index 75a091c276..3ecab50281 100644 --- a/src/mem/cache/compressors/cpack.hh +++ b/src/mem/cache/compressors/cpack.hh @@ -145,31 +145,12 @@ class CPack::PatternZZZZ : public DictionaryCompressor::Pattern } }; -class CPack::PatternXXXX : public DictionaryCompressor::Pattern +class CPack::PatternXXXX : public UncompressedPattern { - private: - /** - * A copy of the word. - */ - const DictionaryEntry bytes; - public: PatternXXXX(const DictionaryEntry bytes, const int match_location) - : Pattern(XXXX, 0x1, 2, 4, 0, true), bytes(bytes) {} - - static bool isPattern(const DictionaryEntry& bytes, - const DictionaryEntry& dict_bytes, - const int match_location) + : UncompressedPattern(XXXX, 0x1, 2, match_location, bytes) { - // It can always be an unmatch, as it is set to this class when other - // patterns fail - return true; - } - - DictionaryEntry - decompress(const DictionaryEntry dict_bytes) const override - { - return bytes; } }; diff --git a/src/mem/cache/compressors/dictionary_compressor.hh b/src/mem/cache/compressors/dictionary_compressor.hh index 7467d5a175..9e0e4df804 100644 --- a/src/mem/cache/compressors/dictionary_compressor.hh +++ b/src/mem/cache/compressors/dictionary_compressor.hh @@ -119,6 +119,7 @@ class DictionaryCompressor : public BaseDictionaryCompressor // Forward declaration of a pattern class Pattern; + class UncompressedPattern; /** Convenience typedef for a dictionary entry. */ typedef std::array DictionaryEntry; @@ -150,15 +151,23 @@ class DictionaryCompressor : public BaseDictionaryCompressor } }; - /** Specialization to end the recursion. */ + /** + * Specialization to end the recursion. This must be called when all + * other patterns failed, and there is no choice but to leave data + * uncompressed. As such, this pattern must inherit from the uncompressed + * pattern. + */ template struct Factory { + static_assert(std::is_base_of::value, + "The last pattern must always be derived from the uncompressed " + "pattern."); + static std::unique_ptr getPattern(const DictionaryEntry& bytes, const DictionaryEntry& dict_bytes, const int match_location) { - // Instantiate last pattern. Should be the XXXX pattern. return std::unique_ptr(new Head(bytes, match_location)); } }; @@ -371,4 +380,44 @@ class DictionaryCompressor::CompData : public CompressionData virtual void addEntry(std::unique_ptr); }; +/** + * A pattern containing the original uncompressed data. This should be the + * worst case of every pattern factory, where if all other patterns fail, + * an instance of this pattern is created. + */ +template +class DictionaryCompressor::UncompressedPattern + : public DictionaryCompressor::Pattern +{ + private: + /** A copy of the original data. */ + const DictionaryEntry data; + + public: + UncompressedPattern(const int number, + const uint64_t code, + const uint64_t metadata_length, + const int match_location, + const DictionaryEntry bytes) + : DictionaryCompressor::Pattern(number, code, metadata_length, + sizeof(T), match_location, true), + data(bytes) + { + } + + static bool + isPattern(const DictionaryEntry& bytes, const DictionaryEntry& dict_bytes, + const int match_location) + { + // An entry can always be uncompressed + return true; + } + + DictionaryEntry + decompress(const DictionaryEntry dict_bytes) const override + { + return data; + } +}; + #endif //__MEM_CACHE_COMPRESSORS_DICTIONARY_COMPRESSOR_HH__