From 7973e49187a977b26cc3abc8a5b1393eb1a1f294 Mon Sep 17 00:00:00 2001 From: "Daniel R. Carvalho" Date: Tue, 17 Sep 2019 17:02:04 +0200 Subject: mem-cache: Add an uncompressed pattern to compressors The uncompressed pattern always stores the original data, and therefore it is always successful. All of the derived classes of the dictionary compressor must have this pattern as the last pattern of the pattern factory. Change-Id: I2a38fd56630d88ef8b918220dc4c2824a196a8a2 Signed-off-by: Daniel R. Carvalho Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/21149 Reviewed-by: Nikos Nikoleris Maintainer: Nikos Nikoleris Tested-by: kokoro --- src/mem/cache/compressors/cpack.hh | 23 +--------- src/mem/cache/compressors/dictionary_compressor.hh | 53 +++++++++++++++++++++- 2 files changed, 53 insertions(+), 23 deletions(-) (limited to 'src/mem/cache/compressors') diff --git a/src/mem/cache/compressors/cpack.hh b/src/mem/cache/compressors/cpack.hh index 75a091c27..3ecab5028 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) - { - // 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 + : UncompressedPattern(XXXX, 0x1, 2, match_location, bytes) { - return bytes; } }; diff --git a/src/mem/cache/compressors/dictionary_compressor.hh b/src/mem/cache/compressors/dictionary_compressor.hh index 7467d5a17..9e0e4df80 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__ -- cgit v1.2.3