From: Daniel R. Carvalho Date: Thu, 5 Sep 2019 13:29:45 +0000 (+0200) Subject: mem-cache: Implement a repeated values compressor X-Git-Tag: v19.0.0.0~334 X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=e41588297291580a99fdf9b7e434ba8145784889;p=gem5.git mem-cache: Implement a repeated values compressor The repeated values compressor can only compress data composed solely repeated instances of the same value. Change-Id: If2c4f47ad4af492d202ec2017e30ba52ee67e307 Signed-off-by: Daniel R. Carvalho Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/21156 Tested-by: kokoro Reviewed-by: Bobby R. Bruce Maintainer: Bobby R. Bruce --- diff --git a/src/mem/cache/compressors/Compressors.py b/src/mem/cache/compressors/Compressors.py index a8e51a577..721b6a251 100644 --- a/src/mem/cache/compressors/Compressors.py +++ b/src/mem/cache/compressors/Compressors.py @@ -69,6 +69,11 @@ class FPCD(BaseDictionaryCompressor): dictionary_size = 2 +class RepeatedQwordsCompressor(BaseDictionaryCompressor): + type = 'RepeatedQwordsCompressor' + cxx_class = 'RepeatedQwordsCompressor' + cxx_header = "mem/cache/compressors/repeated_qwords.hh" + class ZeroCompressor(BaseDictionaryCompressor): type = 'ZeroCompressor' cxx_class = 'ZeroCompressor' diff --git a/src/mem/cache/compressors/SConscript b/src/mem/cache/compressors/SConscript index 27d852dbc..05c1edede 100644 --- a/src/mem/cache/compressors/SConscript +++ b/src/mem/cache/compressors/SConscript @@ -37,4 +37,5 @@ Source('base_dictionary_compressor.cc') Source('bdi.cc') Source('cpack.cc') Source('fpcd.cc') +Source('repeated_qwords.cc') Source('zero.cc') diff --git a/src/mem/cache/compressors/repeated_qwords.cc b/src/mem/cache/compressors/repeated_qwords.cc new file mode 100644 index 000000000..b3e7f3f07 --- /dev/null +++ b/src/mem/cache/compressors/repeated_qwords.cc @@ -0,0 +1,83 @@ +/* + * Copyright (c) 2019 Inria + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer; + * redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution; + * neither the name of the copyright holders nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * Authors: Daniel Carvalho + */ + +/** @file + * Implementation of a repeated values compressor, which compresses data if + * it is entirely composed of repeated qwords. + */ + +#include "mem/cache/compressors/repeated_qwords.hh" + +#include "debug/CacheComp.hh" +#include "mem/cache/compressors/dictionary_compressor_impl.hh" +#include "params/RepeatedQwordsCompressor.hh" + +RepeatedQwordsCompressor::RepeatedQwordsCompressor(const Params *p) + : DictionaryCompressor(p) +{ +} + +void +RepeatedQwordsCompressor::addToDictionary(DictionaryEntry data) +{ + assert(numEntries < dictionarySize); + dictionary[numEntries++] = data; +} + +std::unique_ptr +RepeatedQwordsCompressor::compress(const uint64_t* data, Cycles& comp_lat, + Cycles& decomp_lat) +{ + std::unique_ptr comp_data = + DictionaryCompressor::compress(data); + + // Since there is a single value repeated over and over, there should be + // a single dictionary entry. If there are more, the compressor failed + assert(numEntries >= 1); + if (numEntries > 1) { + comp_data->setSizeBits(blkSize * 8); + DPRINTF(CacheComp, "Repeated qwords compression failed\n"); + } + + // Set compression latency + comp_lat = Cycles(1); + + // Set decompression latency + decomp_lat = Cycles(1); + + // Return compressed line + return comp_data; +} + +RepeatedQwordsCompressor* +RepeatedQwordsCompressorParams::create() +{ + return new RepeatedQwordsCompressor(this); +} diff --git a/src/mem/cache/compressors/repeated_qwords.hh b/src/mem/cache/compressors/repeated_qwords.hh new file mode 100644 index 000000000..451b7d7be --- /dev/null +++ b/src/mem/cache/compressors/repeated_qwords.hh @@ -0,0 +1,124 @@ +/* + * Copyright (c) 2019 Inria + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer; + * redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution; + * neither the name of the copyright holders nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * Authors: Daniel Carvalho + */ + +/** @file + * Definition of a repeated qwords compressor, which compresses data if + * it is entirely composed of repeated qwords. + */ + +#ifndef __MEM_CACHE_COMPRESSORS_REPEATED_QWORDS_HH__ +#define __MEM_CACHE_COMPRESSORS_REPEATED_QWORDS_HH__ + +#include +#include +#include +#include + +#include "mem/cache/compressors/dictionary_compressor.hh" + +struct RepeatedQwordsCompressorParams; + +class RepeatedQwordsCompressor : public DictionaryCompressor +{ + protected: + using DictionaryEntry = DictionaryCompressor::DictionaryEntry; + + // Forward declaration of all possible patterns + class PatternX; + class PatternM; + + /** + * The patterns proposed in the paper. Each letter represents a byte: + * Z is a null byte, M is a dictionary match, X is a new value. + * These are used as indexes to reference the pattern data. If a new + * pattern is added, it must be done before NUM_PATTERNS. + */ + typedef enum { + X, M, NUM_PATTERNS + } PatternNumber; + + /** + * Convenience factory declaration. The templates must be organized by + * size, with the smallest first, and "no-match" last. + */ + using PatternFactory = Factory; + + uint64_t getNumPatterns() const override { return NUM_PATTERNS; } + + std::string + getName(int number) const override + { + static std::map pattern_names = { + {X, "X"}, {M, "M"} + }; + + return pattern_names[number]; + }; + + std::unique_ptr + getPattern(const DictionaryEntry& bytes, const DictionaryEntry& dict_bytes, + const int match_location) const override + { + return PatternFactory::getPattern(bytes, dict_bytes, match_location); + } + + void addToDictionary(DictionaryEntry data) override; + + std::unique_ptr compress( + const uint64_t* data, Cycles& comp_lat, Cycles& decomp_lat) override; + + public: + typedef RepeatedQwordsCompressorParams Params; + RepeatedQwordsCompressor(const Params *p); + ~RepeatedQwordsCompressor() = default; +}; + +class RepeatedQwordsCompressor::PatternX + : public DictionaryCompressor::UncompressedPattern +{ + public: + PatternX(const DictionaryEntry bytes, const int match_location) + : UncompressedPattern(X, 0, 0, match_location, bytes) + { + } +}; + +class RepeatedQwordsCompressor::PatternM + : public DictionaryCompressor::LocatedMaskedPattern<0xFFFFFFFFFFFFFFFF, 0> +{ + public: + PatternM(const DictionaryEntry bytes, const int match_location) + : LocatedMaskedPattern<0xFFFFFFFFFFFFFFFF, 0>(M, 1, 0, match_location, + bytes) + { + } +}; + +#endif //__MEM_CACHE_COMPRESSORS_REPEATED_QWORDS_HH__