fpc.hh

Go to the documentation of this file.

/*
 * Copyright (c) 2018-2020 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.
 */
 
#ifndef __MEM_CACHE_COMPRESSORS_FPC_HH__
#define __MEM_CACHE_COMPRESSORS_FPC_HH__
 
#include <cstdint>
#include <map>
#include <memory>
#include <string>
#include <type_traits>
#include <vector>
 
#include "base/bitfield.hh"
#include "base/types.hh"
#include "mem/cache/compressors/dictionary_compressor.hh"
 
struct FPCParams;
 
namespace Compressor {
 
class FPC : public DictionaryCompressor<uint32_t>
{
  private:
    using DictionaryEntry = DictionaryCompressor<uint32_t>::DictionaryEntry;
 
    class FPCCompData;
 
    // Declaration of all possible patterns
    class ZeroRun;
    class SignExtended4Bits;
    class SignExtended1Byte;
    class SignExtendedHalfword;
    class ZeroPaddedHalfword;
    class SignExtendedTwoHalfwords;
    class RepBytes;
    class Uncompressed;
 
    typedef enum {
        ZERO_RUN, SIGN_EXTENDED_4_BITS, SIGN_EXTENDED_1_BYTE,
        SIGN_EXTENDED_HALFWORD, ZERO_PADDED_HALFWORD,
        SIGN_EXTENDED_TWO_HALFWORDS, REP_BYTES, UNCOMPRESSED,
        NUM_PATTERNS
    } PatternNumber;
 
    const int zeroRunSizeBits;
 
    uint64_t getNumPatterns() const override { return NUM_PATTERNS; }
 
    std::string
    getName(int number) const override
    {
        static std::map<int, std::string> patternNames = {
            {ZERO_RUN, "ZERO_RUN"},
            {SIGN_EXTENDED_4_BITS, "SignExtended4Bits"},
            {SIGN_EXTENDED_1_BYTE, "SignExtended1Byte"},
            {SIGN_EXTENDED_HALFWORD, "SignExtendedHalfword"},
            {ZERO_PADDED_HALFWORD, "ZeroPaddedHalfword"},
            {SIGN_EXTENDED_TWO_HALFWORDS, "SignExtendedTwoHalfwords"},
            {REP_BYTES, "RepBytes"},
            {UNCOMPRESSED, "Uncompressed"}
        };
 
        return patternNames[number];
    };
 
    std::unique_ptr<Pattern> getPattern(
        const DictionaryEntry& bytes,
        const DictionaryEntry& dict_bytes,
        const int match_location) const override
    {
        using PatternFactory = Factory<ZeroRun, SignExtended4Bits,
            SignExtended1Byte, SignExtendedHalfword, ZeroPaddedHalfword,
            SignExtendedTwoHalfwords, RepBytes, Uncompressed>;
        return PatternFactory::getPattern(bytes, dict_bytes, match_location);
    }
 
    void addToDictionary(const DictionaryEntry data) override;
 
    std::unique_ptr<DictionaryCompressor::CompData>
    instantiateDictionaryCompData() const override;
 
  public:
    typedef FPCParams Params;
    FPC(const Params &p);
    ~FPC() = default;
};
 
class FPC::FPCCompData : public DictionaryCompressor<uint32_t>::CompData
{
  protected:
    const int zeroRunSizeBits;
 
  public:
    FPCCompData(int zeroRunSizeBits);
    ~FPCCompData() = default;
 
    void addEntry(std::unique_ptr<Pattern> pattern) override;
};
 
// Pattern implementations
 
class FPC::ZeroRun : public MaskedValuePattern<0, 0xFFFFFFFF>
{
  private:
    int _runLength;
 
    int _realSize;
 
  public:
    ZeroRun(const DictionaryEntry bytes, const int match_location)
      : MaskedValuePattern<0, 0xFFFFFFFF>(ZERO_RUN, ZERO_RUN, 3, -1, bytes,
            false),
        _runLength(0), _realSize(0)
    {
    }
 
    std::size_t
    getSizeBits() const override
    {
        return _realSize;
    }
 
    int getRunLength() const { return _runLength; }
 
    void setRunLength(int length) { _runLength = length; }
 
    void setRealSize(int size) { _realSize = length + size; }
};
 
class FPC::SignExtended4Bits : public SignExtendedPattern<4>
{
  public:
    SignExtended4Bits(const DictionaryEntry bytes, const int match_location)
      : SignExtendedPattern<4>(SIGN_EXTENDED_4_BITS, SIGN_EXTENDED_4_BITS, 3,
        bytes)
    {
    }
};
 
class FPC::SignExtended1Byte : public SignExtendedPattern<8>
{
  public:
    SignExtended1Byte(const DictionaryEntry bytes, const int match_location)
      : SignExtendedPattern<8>(SIGN_EXTENDED_1_BYTE, SIGN_EXTENDED_1_BYTE, 3,
        bytes)
    {
    }
};
 
class FPC::SignExtendedHalfword : public SignExtendedPattern<16>
{
  public:
    SignExtendedHalfword(const DictionaryEntry bytes, const int match_location)
      : SignExtendedPattern<16>(SIGN_EXTENDED_HALFWORD, SIGN_EXTENDED_HALFWORD,
        3, bytes)
    {
    }
};
 
class FPC::ZeroPaddedHalfword : public MaskedValuePattern<0, 0x0000FFFF>
{
  public:
    ZeroPaddedHalfword(const DictionaryEntry bytes, const int match_location)
      : MaskedValuePattern<0, 0x0000FFFF>(ZERO_PADDED_HALFWORD,
        ZERO_PADDED_HALFWORD, 3, -1, bytes, false)
    {
    }
};
 
class FPC::SignExtendedTwoHalfwords : public Pattern
{
  private:
    const int8_t extendedBytes[2];
 
  public:
    SignExtendedTwoHalfwords(const DictionaryEntry bytes,
        const int match_location)
      : Pattern(SIGN_EXTENDED_TWO_HALFWORDS, SIGN_EXTENDED_TWO_HALFWORDS, 3,
            16, -1, false),
        extendedBytes{int8_t(fromDictionaryEntry(bytes) & mask(8)),
            int8_t((fromDictionaryEntry(bytes) >> 16) & mask(8))}
    {
    }
 
    static bool
    isPattern(const DictionaryEntry& bytes,
        const DictionaryEntry& dict_bytes, const int match_location)
    {
        const uint32_t data = fromDictionaryEntry(bytes);
        const int16_t halfwords[2] = {
            int16_t(data & mask(16)),
            int16_t((data >> 16) & mask(16))
        };
        return (halfwords[0] == sext<8>(halfwords[0] & mask(8))) &&
            (halfwords[1] == sext<8>(halfwords[1] & mask(8)));
    }
 
    DictionaryEntry
    decompress(const DictionaryEntry dict_bytes) const override
    {
        uint16_t halfwords[2] = {
            uint16_t(sext<8>(extendedBytes[0]) & mask(16)),
            uint16_t(sext<8>(extendedBytes[1]) & mask(16))
        };
        return toDictionaryEntry((halfwords[1] << 16) | halfwords[0]);
    }
};
 
class FPC::RepBytes : public RepeatedValuePattern<uint8_t>
{
  public:
    RepBytes(const DictionaryEntry bytes, const int match_location)
      : RepeatedValuePattern<uint8_t>(REP_BYTES, REP_BYTES, 3, -1, bytes,
        false)
    {
    }
};
 
class FPC::Uncompressed : public UncompressedPattern
{
  public:
    Uncompressed(const DictionaryEntry bytes, const int match_location)
      : UncompressedPattern(UNCOMPRESSED, UNCOMPRESSED, 3, -1, bytes)
    {
    }
};
 
} // namespace Compressor
 
#endif //__MEM_CACHE_COMPRESSORS_FPC_HH__