From fcc1964453487e6f9ebf518aa4be6195fb20ba1a Mon Sep 17 00:00:00 2001 From: "Daniel R. Carvalho" Date: Thu, 5 Sep 2019 12:00:18 +0200 Subject: [PATCH] mem-cache: Implement a zero compressor The zero compressor can only compress data composed solely of zero bits. Change-Id: I8b359c03776a8748abd144a178bda944b5a1b766 Signed-off-by: Daniel R. Carvalho Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/21155 Tested-by: kokoro Reviewed-by: Bobby R. Bruce Maintainer: Bobby R. Bruce --- src/mem/cache/compressors/Compressors.py | 5 + src/mem/cache/compressors/SConscript | 1 + src/mem/cache/compressors/zero.cc | 81 +++++++++++++++ src/mem/cache/compressors/zero.hh | 125 +++++++++++++++++++++++ 4 files changed, 212 insertions(+) create mode 100644 src/mem/cache/compressors/zero.cc create mode 100644 src/mem/cache/compressors/zero.hh diff --git a/src/mem/cache/compressors/Compressors.py b/src/mem/cache/compressors/Compressors.py index 4db6d4316..a8e51a577 100644 --- a/src/mem/cache/compressors/Compressors.py +++ b/src/mem/cache/compressors/Compressors.py @@ -68,3 +68,8 @@ class FPCD(BaseDictionaryCompressor): cxx_header = "mem/cache/compressors/fpcd.hh" dictionary_size = 2 + +class ZeroCompressor(BaseDictionaryCompressor): + type = 'ZeroCompressor' + cxx_class = 'ZeroCompressor' + cxx_header = "mem/cache/compressors/zero.hh" diff --git a/src/mem/cache/compressors/SConscript b/src/mem/cache/compressors/SConscript index 4df20d2a3..27d852dbc 100644 --- a/src/mem/cache/compressors/SConscript +++ b/src/mem/cache/compressors/SConscript @@ -37,3 +37,4 @@ Source('base_dictionary_compressor.cc') Source('bdi.cc') Source('cpack.cc') Source('fpcd.cc') +Source('zero.cc') diff --git a/src/mem/cache/compressors/zero.cc b/src/mem/cache/compressors/zero.cc new file mode 100644 index 000000000..3fdf5f1e8 --- /dev/null +++ b/src/mem/cache/compressors/zero.cc @@ -0,0 +1,81 @@ +/* + * 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 zero compressor, which compressed data if it is entirely + * composed of zero bits. + */ + +#include "mem/cache/compressors/zero.hh" + +#include "debug/CacheComp.hh" +#include "mem/cache/compressors/dictionary_compressor_impl.hh" +#include "params/ZeroCompressor.hh" + +ZeroCompressor::ZeroCompressor(const Params *p) + : DictionaryCompressor(p) +{ +} + +void +ZeroCompressor::addToDictionary(DictionaryEntry data) +{ + assert(numEntries < dictionarySize); + dictionary[numEntries++] = data; +} + +std::unique_ptr +ZeroCompressor::compress(const uint64_t* data, Cycles& comp_lat, + Cycles& decomp_lat) +{ + std::unique_ptr comp_data = + DictionaryCompressor::compress(data); + + // If there is any non-zero entry, the compressor failed + if (numEntries > 0) { + comp_data->setSizeBits(blkSize * 8); + DPRINTF(CacheComp, "Zero compression failed\n"); + } + + // Set compression latency (Assumes full line zero comparison) + comp_lat = Cycles(1); + + // Set decompression latency + decomp_lat = Cycles(1); + + // Return compressed line + return comp_data; +} + +ZeroCompressor* +ZeroCompressorParams::create() +{ + return new ZeroCompressor(this); +} diff --git a/src/mem/cache/compressors/zero.hh b/src/mem/cache/compressors/zero.hh new file mode 100644 index 000000000..62b363349 --- /dev/null +++ b/src/mem/cache/compressors/zero.hh @@ -0,0 +1,125 @@ +/* + * 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 zero compressor, which compressed data if it is entirely + * composed of zero bits. + */ + +#ifndef __MEM_CACHE_COMPRESSORS_ZERO_HH__ +#define __MEM_CACHE_COMPRESSORS_ZERO_HH__ + +#include +#include +#include +#include + +#include "mem/cache/compressors/dictionary_compressor.hh" + +struct ZeroCompressorParams; + +class ZeroCompressor : public DictionaryCompressor +{ + protected: + using DictionaryEntry = DictionaryCompressor::DictionaryEntry; + + // Forward declaration of all possible patterns + class PatternX; + class PatternZ; + + /** + * 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, Z, 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"}, {Z, "Z"} + }; + + 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 ZeroCompressorParams Params; + ZeroCompressor(const Params *p); + ~ZeroCompressor() = default; +}; + +class ZeroCompressor::PatternX + : public DictionaryCompressor::UncompressedPattern +{ + public: + PatternX(const DictionaryEntry bytes, const int match_location) + : DictionaryCompressor::UncompressedPattern(X, 0, 1, match_location, + bytes) + { + } +}; + +class ZeroCompressor::PatternZ + : public DictionaryCompressor::MaskedValuePattern<0, 0xFFFFFFFFFFFFFFFF> +{ + public: + PatternZ(const DictionaryEntry bytes, const int match_location) + : DictionaryCompressor::MaskedValuePattern<0, 0xFFFFFFFFFFFFFFFF>( + Z, 1, 1, match_location, bytes) + { + } +}; + +#endif //__MEM_CACHE_COMPRESSORS_ZERO_HH__ -- 2.30.2