release/v19-0-0-0/dictionary__compressor_8hh_source.html

 /*
  * Copyright (c) 2018-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
  */

 #ifndef __MEM_CACHE_COMPRESSORS_DICTIONARY_COMPRESSOR_HH__
 #define __MEM_CACHE_COMPRESSORS_DICTIONARY_COMPRESSOR_HH__

 #include <array>
 #include <cstdint>
 #include <map>
 #include <memory>
 #include <string>
 #include <type_traits>
 #include <vector>

 #include "base/types.hh"
 #include "mem/cache/compressors/base.hh"

 struct BaseDictionaryCompressorParams;

 class BaseDictionaryCompressor : public BaseCacheCompressor
 {
   protected:
     const std::size_t dictionarySize;

     std::size_t numEntries;

     Stats::Vector patternStats;

     virtual uint64_t getNumPatterns() const = 0;

     virtual std::string getName(int number) const = 0;

   public:
     typedef BaseDictionaryCompressorParams Params;
     BaseDictionaryCompressor(const Params *p);
     ~BaseDictionaryCompressor() = default;

     void regStats() override;
 };

 template <class T>
 class DictionaryCompressor : public BaseDictionaryCompressor
 {
   protected:
     typedef std::array<uint8_t, sizeof(T)> DictionaryEntry;

     class CompData;

     // Forward declaration of a pattern
     class Pattern;
     class UncompressedPattern;
     template <T mask>
     class MaskedPattern;
     template <T value, T mask>
     class MaskedValuePattern;
     template <T mask, int location>
     class LocatedMaskedPattern;
     template <class RepT>
     class RepeatedValuePattern;
     template <std::size_t DeltaSizeBits>
     class DeltaPattern;

     template <class Head, class... Tail>
     struct Factory
     {
         static std::unique_ptr<Pattern> getPattern(
             const DictionaryEntry& bytes, const DictionaryEntry& dict_bytes,
             const int match_location)
         {
             // If match this pattern, instantiate it. If a negative match
             // location is used, the patterns that use the dictionary bytes
             // must return false. This is used when there are no dictionary
             // entries yet
             if (Head::isPattern(bytes, dict_bytes, match_location)) {
                 return std::unique_ptr<Pattern>(
                             new Head(bytes, match_location));
             // Otherwise, go for next pattern
             } else {
                 return Factory<Tail...>::getPattern(bytes, dict_bytes,
                                                     match_location);
             }
         }
     };

     template <class Head>
     struct Factory<Head>
     {
         static_assert(std::is_base_of<UncompressedPattern, Head>::value,
             "The last pattern must always be derived from the uncompressed "
             "pattern.");

         static std::unique_ptr<Pattern>
         getPattern(const DictionaryEntry& bytes,
             const DictionaryEntry& dict_bytes, const int match_location)
         {
             return std::unique_ptr<Pattern>(new Head(bytes, match_location));
         }
     };

     std::vector<DictionaryEntry> dictionary;

     virtual std::unique_ptr<Pattern>
     getPattern(const DictionaryEntry& bytes, const DictionaryEntry& dict_bytes,
         const int match_location) const = 0;

     std::unique_ptr<Pattern> compressValue(const T data);

     T decompressValue(const Pattern* pattern);

     virtual void resetDictionary();

     virtual void addToDictionary(const DictionaryEntry data) = 0;

     std::unique_ptr<BaseCacheCompressor::CompressionData> compress(
         const uint64_t* data);

     using BaseDictionaryCompressor::compress;

     void decompress(const CompressionData* comp_data, uint64_t* data) override;

     static DictionaryEntry toDictionaryEntry(T value);

     static T fromDictionaryEntry(const DictionaryEntry& entry);

   public:
     typedef BaseDictionaryCompressorParams Params;
     DictionaryCompressor(const Params *p);
     ~DictionaryCompressor() = default;
 };

 template <class T>
 class DictionaryCompressor<T>::Pattern
 {
   protected:
     const int patternNumber;

     const uint8_t code;

     const uint8_t length;

     const uint8_t numUnmatchedBits;

     const int matchLocation;

     const bool allocate;

   public:
     Pattern(const int number, const uint64_t code,
             const uint64_t metadata_length, const uint64_t num_unmatched_bits,
             const int match_location, const bool allocate = true)
         : patternNumber(number), code(code), length(metadata_length),
           numUnmatchedBits(num_unmatched_bits),
           matchLocation(match_location), allocate(allocate)
     {
     }

     virtual ~Pattern() = default;

     int getPatternNumber() const { return patternNumber; };

     uint8_t getCode() const { return code; }

     uint8_t getMatchLocation() const { return matchLocation; }

     std::size_t
     getSizeBits() const
     {
         return numUnmatchedBits + length;
     }

     bool shouldAllocate() const { return allocate; }

     std::string
     print() const
     {
         return csprintf("pattern %s (encoding %x, size %u bits)",
                         getPatternNumber(), getCode(), getSizeBits());
     }

     virtual DictionaryEntry decompress(
         const DictionaryEntry dict_bytes) const = 0;
 };

 template <class T>
 class DictionaryCompressor<T>::CompData : public CompressionData
 {
   public:
     std::vector<std::unique_ptr<Pattern>> entries;

     CompData();
     ~CompData() = default;

     virtual void addEntry(std::unique_ptr<Pattern>);
 };

 template <class T>
 class DictionaryCompressor<T>::UncompressedPattern
     : public DictionaryCompressor<T>::Pattern
 {
   private:
     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<T>::Pattern(number, code, metadata_length,
             sizeof(T) * 8, 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;
     }
 };

 template <class T>
 template <T mask>
 class DictionaryCompressor<T>::MaskedPattern
     : public DictionaryCompressor<T>::Pattern
 {
   private:
     static_assert(mask != 0, "The pattern's value mask must not be zero. Use "
         "the uncompressed pattern instead.");

     const T bits;

   public:
     MaskedPattern(const int number,
         const uint64_t code,
         const uint64_t metadata_length,
         const int match_location,
         const DictionaryEntry bytes,
         const bool allocate = true)
       : DictionaryCompressor<T>::Pattern(number, code, metadata_length,
             popCount(~mask), match_location, allocate),
         bits(DictionaryCompressor<T>::fromDictionaryEntry(bytes) & ~mask)
     {
     }

     static bool
     isPattern(const DictionaryEntry& bytes, const DictionaryEntry& dict_bytes,
         const int match_location)
     {
         const T masked_bytes =
             DictionaryCompressor<T>::fromDictionaryEntry(bytes) & mask;
         const T masked_dict_bytes =
             DictionaryCompressor<T>::fromDictionaryEntry(dict_bytes) & mask;
         return (match_location >= 0) && (masked_bytes == masked_dict_bytes);
     }

     DictionaryEntry
     decompress(const DictionaryEntry dict_bytes) const override
     {
         const T masked_dict_bytes =
             DictionaryCompressor<T>::fromDictionaryEntry(dict_bytes) & mask;
         return DictionaryCompressor<T>::toDictionaryEntry(
             bits | masked_dict_bytes);
     }
 };

 template <class T>
 template <T value, T mask>
 class DictionaryCompressor<T>::MaskedValuePattern
     : public MaskedPattern<mask>
 {
   private:
     static_assert(mask != 0, "The pattern's value mask must not be zero.");

   public:
     MaskedValuePattern(const int number,
         const uint64_t code,
         const uint64_t metadata_length,
         const int match_location,
         const DictionaryEntry bytes,
         const bool allocate = false)
       : MaskedPattern<mask>(number, code, metadata_length, match_location,
             bytes, allocate)
     {
     }

     static bool
     isPattern(const DictionaryEntry& bytes, const DictionaryEntry& dict_bytes,
         const int match_location)
     {
         // Compare the masked fixed value to the value being checked for
         // patterns. Since the dictionary is not being used the match_location
         // is irrelevant.
         const T masked_bytes =
             DictionaryCompressor<T>::fromDictionaryEntry(bytes) & mask;
         return ((value & mask) == masked_bytes);
     }

     DictionaryEntry
     decompress(const DictionaryEntry dict_bytes) const override
     {
         return MaskedPattern<mask>::decompress(
             DictionaryCompressor<T>::toDictionaryEntry(value));
     }
 };

 template <class T>
 template <T mask, int location>
 class DictionaryCompressor<T>::LocatedMaskedPattern
     : public MaskedPattern<mask>
 {
   public:
     LocatedMaskedPattern(const int number,
         const uint64_t code,
         const uint64_t metadata_length,
         const int match_location,
         const DictionaryEntry bytes)
       : MaskedPattern<mask>(number, code, metadata_length, match_location,
             bytes)
     {
     }

     static bool
     isPattern(const DictionaryEntry& bytes, const DictionaryEntry& dict_bytes,
         const int match_location)
     {
         // Besides doing the regular masked pattern matching, the match
         // location must match perfectly with this instance's
         return (match_location == location) &&
             MaskedPattern<mask>::isPattern(bytes, dict_bytes, match_location);
     }
 };

 template <class T>
 template <class RepT>
 class DictionaryCompressor<T>::RepeatedValuePattern
     : public DictionaryCompressor<T>::Pattern
 {
   private:
     static_assert(sizeof(T) > sizeof(RepT), "The repeated value's type must "
         "be smaller than the dictionary entry's type.");

     RepT value;

   public:
     RepeatedValuePattern(const int number,
         const uint64_t code,
         const uint64_t metadata_length,
         const int match_location,
         const DictionaryEntry bytes,
         const bool allocate = true)
       : DictionaryCompressor<T>::Pattern(number, code, metadata_length,
             8 * sizeof(RepT), match_location, allocate),
         value(DictionaryCompressor<T>::fromDictionaryEntry(bytes))
     {
     }

     static bool
     isPattern(const DictionaryEntry& bytes, const DictionaryEntry& dict_bytes,
         const int match_location)
     {
         // Parse the dictionary entry in a RepT granularity, and if all values
         // are equal, this is a repeated value pattern. Since the dictionary
         // is not being used, the match_location is irrelevant
         T bytes_value = DictionaryCompressor<T>::fromDictionaryEntry(bytes);
         const RepT rep_value = bytes_value;
         for (int i = 0; i < (sizeof(T) / sizeof(RepT)); i++) {
             RepT cur_value = bytes_value;
             if (cur_value != rep_value) {
                 return false;
             }
             bytes_value >>= 8 * sizeof(RepT);
         }
         return true;
     }

     DictionaryEntry
     decompress(const DictionaryEntry dict_bytes) const override
     {
         // The decompressed value is just multiple consecutive instances of
         // the same value
         T decomp_value = 0;
         for (int i = 0; i < (sizeof(T) / sizeof(RepT)); i++) {
             decomp_value <<= 8 * sizeof(RepT);
             decomp_value |= value;
         }
         return DictionaryCompressor<T>::toDictionaryEntry(decomp_value);
     }
 };

 template <class T>
 template <std::size_t DeltaSizeBits>
 class DictionaryCompressor<T>::DeltaPattern
     : public DictionaryCompressor<T>::Pattern
 {
   private:
     static_assert(DeltaSizeBits < (sizeof(T) * 8),
         "Delta size must be smaller than base size");

     const DictionaryEntry bytes;

   public:
     DeltaPattern(const int number,
         const uint64_t code,
         const uint64_t metadata_length,
         const int match_location,
         const DictionaryEntry bytes)
       : DictionaryCompressor<T>::Pattern(number, code, metadata_length,
             DeltaSizeBits, match_location, false),
         bytes(bytes)
     {
     }

     static bool
     isValidDelta(const DictionaryEntry& bytes,
         const DictionaryEntry& base_bytes)
     {
         const typename std::make_signed<T>::type limit = DeltaSizeBits ?
             mask(DeltaSizeBits - 1) : 0;
         const T value =
             DictionaryCompressor<T>::fromDictionaryEntry(bytes);
         const T base =
             DictionaryCompressor<T>::fromDictionaryEntry(base_bytes);
         const typename std::make_signed<T>::type delta = value - base;
         return (delta >= -limit) && (delta <= limit);
     }

     static bool
     isPattern(const DictionaryEntry& bytes,
         const DictionaryEntry& dict_bytes, const int match_location)
     {
         return (match_location >= 0) && isValidDelta(bytes, dict_bytes);
     }

     DictionaryEntry
     decompress(const DictionaryEntry dict_bytes) const override
     {
         return bytes;
     }
 };

 #endif //__MEM_CACHE_COMPRESSORS_DICTIONARY_COMPRESSOR_HH__
DictionaryCompressor::MaskedValuePattern::MaskedValuePattern
MaskedValuePattern(const int number, const uint64_t code, const uint64_t metadata_length, const int match_location, const DictionaryEntry bytes, const bool allocate=false)
Definition: dictionary_compressor.hh:519

BaseCacheCompressor::compress
virtual std::unique_ptr< CompressionData > compress(const uint64_t *cache_line, Cycles &comp_lat, Cycles &decomp_lat)=0
Apply the compression process to the cache line.

DictionaryCompressor::MaskedPattern
A pattern that compares masked values against dictionary entries.
Definition: dictionary_compressor.hh:128

DictionaryCompressor::LocatedMaskedPattern::isPattern
static bool isPattern(const DictionaryEntry &bytes, const DictionaryEntry &dict_bytes, const int match_location)
Definition: dictionary_compressor.hh:574

DictionaryCompressor::Pattern::getMatchLocation
uint8_t getMatchLocation() const
Get the index of the dictionary match location.
Definition: dictionary_compressor.hh:334

DictionaryCompressor::UncompressedPattern::decompress
DictionaryEntry decompress(const DictionaryEntry dict_bytes) const override
Decompress the pattern.
Definition: dictionary_compressor.hh:430

ArmISA::i
Bitfield< 7 > i
Definition: miscregs_types.hh:66

DictionaryCompressor::toDictionaryEntry
static DictionaryEntry toDictionaryEntry(T value)
Turn a value into a dictionary entry.
Definition: dictionary_compressor_impl.hh:191

BaseDictionaryCompressor::regStats
void regStats() override
Callback to set stat parameters.
Definition: base_dictionary_compressor.cc:45

DictionaryCompressor::Factory< Head >::getPattern
static std::unique_ptr< Pattern > getPattern(const DictionaryEntry &bytes, const DictionaryEntry &dict_bytes, const int match_location)
Definition: dictionary_compressor.hh:179

DictionaryCompressor::MaskedPattern::isPattern
static bool isPattern(const DictionaryEntry &bytes, const DictionaryEntry &dict_bytes, const int match_location)
Definition: dictionary_compressor.hh:474

base.hh
Definition of a basic cache compressor.

Stats::Vector
A vector of scalar stats.
Definition: statistics.hh:2550

popCount
int popCount(uint64_t val)
Returns the number of set ones in the provided value.
Definition: bitfield.hh:249

BaseDictionaryCompressor::numEntries
std::size_t numEntries
Number of valid entries in the dictionary.
Definition: dictionary_compressor.hh:68

DictionaryCompressor::DeltaPattern::isPattern
static bool isPattern(const DictionaryEntry &bytes, const DictionaryEntry &dict_bytes, const int match_location)
Definition: dictionary_compressor.hh:717

DictionaryCompressor::MaskedValuePattern
A pattern that compares masked values to a masked portion of a fixed value.
Definition: dictionary_compressor.hh:130

DictionaryCompressor::Pattern::getCode
uint8_t getCode() const
Get code of this pattern.
Definition: dictionary_compressor.hh:327

DictionaryCompressor::Pattern::shouldAllocate
bool shouldAllocate() const
Determine if pattern allocates a dictionary entry.
Definition: dictionary_compressor.hh:353

std::vector< DictionaryEntry >

DictionaryCompressor::Pattern::print
std::string print() const
Extract pattern&#39;s information to a string.
Definition: dictionary_compressor.hh:361

BaseDictionaryCompressor::dictionarySize
const std::size_t dictionarySize
Dictionary size.
Definition: dictionary_compressor.hh:65

DictionaryCompressor::RepeatedValuePattern::isPattern
static bool isPattern(const DictionaryEntry &bytes, const DictionaryEntry &dict_bytes, const int match_location)
Definition: dictionary_compressor.hh:620

DictionaryCompressor::Pattern::getSizeBits
std::size_t getSizeBits() const
Get size, in bits, of the pattern (excluding prefix).
Definition: dictionary_compressor.hh:343

DictionaryCompressor::Pattern::getPatternNumber
int getPatternNumber() const
Get enum number associated to this pattern.
Definition: dictionary_compressor.hh:320

type
uint8_t type
Definition: inet.hh:333

BaseDictionaryCompressor::~BaseDictionaryCompressor
~BaseDictionaryCompressor()=default

csprintf
std::string csprintf(const char *format, const Args &...args)
Definition: cprintf.hh:162

BaseDictionaryCompressor::getName
virtual std::string getName(int number) const =0
Get meta-name assigned to the given pattern.

DictionaryCompressor::CompData
Definition: dictionary_compressor.hh:379

BaseDictionaryCompressor::Params
BaseDictionaryCompressorParams Params
Definition: dictionary_compressor.hh:98

BaseDictionaryCompressor::getNumPatterns
virtual uint64_t getNumPatterns() const =0
Trick function to get the number of patterns.

X86ISA::base
Bitfield< 51, 12 > base
Definition: pagetable.hh:142

DictionaryCompressor::Factory
Create a factory to determine if input matches a pattern.
Definition: dictionary_compressor.hh:144

DictionaryCompressor::Pattern
The compressed data is composed of multiple pattern entries.
Definition: dictionary_compressor.hh:272

DictionaryCompressor::MaskedValuePattern::isPattern
static bool isPattern(const DictionaryEntry &bytes, const DictionaryEntry &dict_bytes, const int match_location)
Definition: dictionary_compressor.hh:531

DictionaryCompressor::Pattern::allocate
const bool allocate
Wether the pattern allocates a dictionary entry or not.
Definition: dictionary_compressor.hh:291

DictionaryCompressor::Pattern::code
const uint8_t code
Code associated to the pattern.
Definition: dictionary_compressor.hh:279

DictionaryCompressor::CompData::entries
std::vector< std::unique_ptr< Pattern > > entries
The patterns matched in the original line.
Definition: dictionary_compressor.hh:383

DictionaryCompressor::RepeatedValuePattern::value
RepT value
The repeated value.
Definition: dictionary_compressor.hh:601

types.hh
Defines global host-dependent types: Counter, Tick, and (indirectly) {int,uint}{8,16,32,64}_t.

DictionaryCompressor::RepeatedValuePattern
A pattern that checks if dictionary entry sized values are solely composed of multiple copies of a si...
Definition: dictionary_compressor.hh:134

BaseCacheCompressor
Base cache compressor interface.
Definition: base.hh:54

DictionaryCompressor::UncompressedPattern::data
const DictionaryEntry data
A copy of the original data.
Definition: dictionary_compressor.hh:407

DictionaryCompressor::LocatedMaskedPattern
A pattern that narrows the MaskedPattern by allowing a only single possible dictionary entry to be ma...
Definition: dictionary_compressor.hh:132

DictionaryCompressor::UncompressedPattern::isPattern
static bool isPattern(const DictionaryEntry &bytes, const DictionaryEntry &dict_bytes, const int match_location)
Definition: dictionary_compressor.hh:422

DictionaryCompressor::fromDictionaryEntry
static T fromDictionaryEntry(const DictionaryEntry &entry)
Turn a dictionary entry into a value.
Definition: dictionary_compressor_impl.hh:203

DictionaryCompressor::DictionaryEntry
std::array< uint8_t, sizeof(T)> DictionaryEntry
Convenience typedef for a dictionary entry.
Definition: dictionary_compressor.hh:116

DictionaryCompressor::UncompressedPattern::UncompressedPattern
UncompressedPattern(const int number, const uint64_t code, const uint64_t metadata_length, const int match_location, const DictionaryEntry bytes)
Definition: dictionary_compressor.hh:410

DictionaryCompressor::dictionary
std::vector< DictionaryEntry > dictionary
The dictionary.
Definition: dictionary_compressor.hh:187

DictionaryCompressor::DeltaPattern::DeltaPattern
DeltaPattern(const int number, const uint64_t code, const uint64_t metadata_length, const int match_location, const DictionaryEntry bytes)
Definition: dictionary_compressor.hh:683

DictionaryCompressor::DeltaPattern
A pattern that checks whether the difference of the value and the dictionary entries&#39; is below a cert...
Definition: dictionary_compressor.hh:136

DictionaryCompressor::Pattern::Pattern
Pattern(const int number, const uint64_t code, const uint64_t metadata_length, const uint64_t num_unmatched_bits, const int match_location, const bool allocate=true)
Default constructor.
Definition: dictionary_compressor.hh:303

BaseDictionaryCompressor::patternStats
Stats::Vector patternStats
Number of data entries that were compressed to each pattern.
Definition: dictionary_compressor.hh:76

DictionaryCompressor::Factory::getPattern
static std::unique_ptr< Pattern > getPattern(const DictionaryEntry &bytes, const DictionaryEntry &dict_bytes, const int match_location)
Definition: dictionary_compressor.hh:146

X86ISA::limit
BitfieldType< SegDescriptorLimit > limit
Definition: misc.hh:926

DictionaryCompressor::UncompressedPattern
A pattern containing the original uncompressed data.
Definition: dictionary_compressor.hh:402

DictionaryCompressor::DeltaPattern::bytes
const DictionaryEntry bytes
The original value.
Definition: dictionary_compressor.hh:673

DictionaryCompressor::Pattern::patternNumber
const int patternNumber
Pattern enum number.
Definition: dictionary_compressor.hh:276

BaseDictionaryCompressor::BaseDictionaryCompressor
BaseDictionaryCompressor(const Params *p)
Definition: base_dictionary_compressor.cc:39

DictionaryCompressor::MaskedPattern::bits
const T bits
A copy of the bits that do not belong to the mask.
Definition: dictionary_compressor.hh:455

DictionaryCompressor::MaskedPattern::MaskedPattern
MaskedPattern(const int number, const uint64_t code, const uint64_t metadata_length, const int match_location, const DictionaryEntry bytes, const bool allocate=true)
Definition: dictionary_compressor.hh:461

DictionaryCompressor::RepeatedValuePattern::decompress
DictionaryEntry decompress(const DictionaryEntry dict_bytes) const override
Decompress the pattern.
Definition: dictionary_compressor.hh:639

DictionaryCompressor::MaskedPattern::decompress
DictionaryEntry decompress(const DictionaryEntry dict_bytes) const override
Decompress the pattern.
Definition: dictionary_compressor.hh:485

DictionaryCompressor::LocatedMaskedPattern::LocatedMaskedPattern
LocatedMaskedPattern(const int number, const uint64_t code, const uint64_t metadata_length, const int match_location, const DictionaryEntry bytes)
Definition: dictionary_compressor.hh:563

DictionaryCompressor::DeltaPattern::decompress
DictionaryEntry decompress(const DictionaryEntry dict_bytes) const override
Decompress the pattern.
Definition: dictionary_compressor.hh:724

ArmISA::mask
Bitfield< 3, 0 > mask
Definition: types.hh:64

length
uint8_t length
Definition: inet.hh:334

DictionaryCompressor::DeltaPattern::isValidDelta
static bool isValidDelta(const DictionaryEntry &bytes, const DictionaryEntry &base_bytes)
Compares a given value against a base to calculate their delta, and then determines whether it fits a...
Definition: dictionary_compressor.hh:703

DictionaryCompressor::Params
BaseDictionaryCompressorParams Params
Definition: dictionary_compressor.hh:260

DictionaryCompressor::Pattern::length
const uint8_t length
Length, in bits, of the code and match location.
Definition: dictionary_compressor.hh:282

DictionaryCompressor::Pattern::numUnmatchedBits
const uint8_t numUnmatchedBits
Number of unmatched bits.
Definition: dictionary_compressor.hh:285

bits
T bits(T val, int first, int last)
Extract the bitfield from position &#39;first&#39; to &#39;last&#39; (inclusive) from &#39;val&#39; and right justify it...
Definition: bitfield.hh:72

BaseDictionaryCompressor
Definition: dictionary_compressor.hh:61

MipsISA::p
Bitfield< 0 > p
Definition: pra_constants.hh:325

data
const char data[]
Definition: circlebuf.test.cc:44

DictionaryCompressor::MaskedValuePattern::decompress
DictionaryEntry decompress(const DictionaryEntry dict_bytes) const override
Decompress the pattern.
Definition: dictionary_compressor.hh:543

DictionaryCompressor::RepeatedValuePattern::RepeatedValuePattern
RepeatedValuePattern(const int number, const uint64_t code, const uint64_t metadata_length, const int match_location, const DictionaryEntry bytes, const bool allocate=true)
Definition: dictionary_compressor.hh:607

BaseCacheCompressor::CompressionData
Definition: base.hh:179

DictionaryCompressor::Pattern::matchLocation
const int matchLocation
Index representing the the match location.
Definition: dictionary_compressor.hh:288

DictionaryCompressor
A template version of the dictionary compressor that allows to choose the dictionary size...
Definition: dictionary_compressor.hh:112

BaseCacheCompressor::decompress
virtual void decompress(const CompressionData *comp_data, uint64_t *cache_line)=0
Apply the decompression process to the compressed data.