MoveSlotDictionary Class Reference

Inheritance diagram for MoveSlotDictionary:

Collaboration diagram for MoveSlotDictionary:

Public Member Functions
	MoveSlotDictionary ()
	~MoveSlotDictionary ()
virtual InstructionBitVector *	compress (const string &programName)
virtual void	generateDecompressor (std::ostream &stream, TCEString entityStr)
virtual void	printDescription (std::ostream &stream)
Public Member Functions inherited from CodeCompressorPlugin
virtual	~CodeCompressorPlugin ()
void	setParameters (ParameterTable parameters)
void	setPrograms (std::map< std::string, TPEF::Binary * > &programs)
void	setMachine (const TTAMachine::Machine &machine)
void	setBEM (const BinaryEncoding &bem)
const BinaryEncoding &	binaryEncoding () const
const TTAMachine::Machine &	machine () const
unsigned int	memoryAddress (const TTAProgram::Instruction &instruction) const
TTAProgram::Program &	currentProgram () const
int	imemMauWidth () const
InstructionBitVector *	bemInstructionBits (const TTAProgram::Instruction &)

Private Types
typedef std::map< BitVector, unsigned int >	Dictionary
	Map type for dictionary. More...

Private Member Functions
void	createDictionary ()
void	updateDictionary (const Program &program)
void	addToDictionary (const BitVector &instructionBits, int slotIndex)
void	addInstructions ()
void	generateDictionaryVhdl (std::ostream &stream, TCEString entityStr)
void	generateDecompressorEntity (std::ostream &stream, TCEString entityStr)
void	generateDecompressorArchitecture (std::ostream &stream, TCEString entityStr)
void	generateDecompressorSignals (std::ostream &stream, bool &haveLimm)
void	generateDecompressorBody (std::ostream &stream, bool &haveLimm)
void	evaluateMoveSlotBoundaries (vector< pair< int, int > > &boundaries)
void	generateDecompressorProcess (std::ostream &stream, bool &haveLimm)
void	printDetails ()

Private Attributes
vector< Dictionary * >	dictionary_
	The dictionary. More...
bool	dictionaryCreated_
	Indicates whether the dictionary has been created. More...
unsigned int	compressedWidth_
	Total width of compressed instruction (limm fields + move slots) More...

Additional Inherited Members
Public Types inherited from CodeCompressorPlugin
typedef std::vector< Parameter >	ParameterTable
	Table for passing plugin parameters. More...
Protected Types inherited from CodeCompressorPlugin
typedef std::map< std::string, TPEF::Binary * >	TPEFMap
	Map type for handling programs. More...
Protected Member Functions inherited from CodeCompressorPlugin
	CodeCompressorPlugin ()
InstructionBitVector *	bemBits (const TTAProgram::Program &program)
int	moveSlotCount () const
int	moveSlotWidth (int index) const
int	firstMoveSlotIndex () const
void	startNewProgram (const std::string &programName)
void	addInstruction (const TTAProgram::Instruction &instruction, InstructionBitVector *bits)
void	setInstructionToStartAtBeginningOfMAU (const TTAProgram::Instruction &instruction)
void	setAllInstructionsToStartAtBeginningOfMAU ()
InstructionBitVector *	programBits () const
bool	hasParameter (const std::string &paramName) const
std::string	parameterValue (const std::string &paramName) const
void	setImemWidth (int mau, int widthInMaus=1)
int	numberOfPrograms () const
TPEFMap::const_iterator	programElement (int index) const
std::string	indentation (int level)

Detailed Description

Definition at line 72 of file MoveSlotDictionary.cc.

Member Typedef Documentation

Dictionary

typedef std::map<BitVector, unsigned int> MoveSlotDictionary::Dictionary

private

Map type for dictionary.

Definition at line 504 of file MoveSlotDictionary.cc.

Constructor & Destructor Documentation

MoveSlotDictionary()

MoveSlotDictionary::MoveSlotDictionary ( )

inline

The constructor

Definition at line 78 of file MoveSlotDictionary.cc.

                        : CodeCompressorPlugin(), dictionaryCreated_(false),
                          compressedWidth_(0) {
    }

~MoveSlotDictionary()

MoveSlotDictionary::~MoveSlotDictionary ( )

inline

The destructor

Definition at line 85 of file MoveSlotDictionary.cc.

                          {
        for (unsigned int i = 0; i < dictionary_.size(); i++) {
            if (dictionary_.at(i) != NULL) {
                delete dictionary_.at(i);
            }
        }   
    }

Member Function Documentation

addInstructions()

void MoveSlotDictionary::addInstructions ( )

inlineprivate

Adds the compressed instructions to the program.

Definition at line 220 of file MoveSlotDictionary.cc.

                      {
        Instruction* instruction = &currentProgram().firstInstruction();
        while (instruction != &NullInstruction::instance()) {
            InstructionBitVector* bemBits = bemInstructionBits(*instruction);
            InstructionBitVector* compressedInstruction = 
                new InstructionBitVector();
            // Take a BitVector pointer to the compressed instruction because
            // we _need_ to use BitVector pushBack-methods!
            BitVector* compressPtr = 
                static_cast<BitVector*>(compressedInstruction);
 
            // handle limm fields, if any
            if (firstMoveSlotIndex() != 0) {
                for (int i = 0; i < firstMoveSlotIndex(); i++) {
                    // false is defined as 0, true is then != 0
                    compressPtr->pushBack(bemBits->at(i) != 0);
                }
            }
            unsigned int begin = firstMoveSlotIndex();
            unsigned int end = begin;
            for (int i = 0; i < moveSlotCount(); i++) {
                end = begin + moveSlotWidth(i)-1;
                BitVector moveSlot(*bemBits, begin, end);
                unsigned int code = MapTools::valueForKey<unsigned int>(
                    *(dictionary_.at(i)), moveSlot);
                // add move slot key to compressed instruction
                compressPtr->pushBack(
                    code, MathTools::requiredBits(dictionary_.at(i)->size()));
 
                begin = end + 1;
            }
            addInstruction(*instruction, compressedInstruction);
            instruction = &currentProgram().nextInstruction(*instruction);
            delete bemBits;
        }
    }

References BitVector::pushBack(), and MathTools::requiredBits().

Here is the call graph for this function:

addToDictionary()

void MoveSlotDictionary::addToDictionary ( const BitVector &  instructionBits, int  slotIndex  )

inlineprivate

Adds the given instruction bits to the move slot dictionary.

Parameters

instructionBits	The instruction bits to add.
slotIndex	Index of the move slot

Definition at line 207 of file MoveSlotDictionary.cc.

                                                                     {
        if (!MapTools::containsKey(
                *(dictionary_.at(slotIndex)), instructionBits)) {
            unsigned int code = dictionary_.at(slotIndex)->size();
            dictionary_.at(slotIndex)->insert(
                std::pair<BitVector, unsigned int>(instructionBits, code));
        }
    }        

References MapTools::containsKey().

Here is the call graph for this function:

compress()

virtual InstructionBitVector* MoveSlotDictionary::compress ( const string &  programName )

inlinevirtual

Creates compressed code of the program and returns it in bit vector

Implements CodeCompressorPlugin.

Definition at line 97 of file MoveSlotDictionary.cc.

                                        {
        if (!dictionaryCreated_) {
            createDictionary();
            // fix imem width (mau == instruction width)
            int imemWidth = 0;
            for (unsigned int i = 0; i < dictionary_.size(); i++) {
                // add dictionary sizes
                imemWidth += 
                    MathTools::requiredBits(dictionary_.at(i)->size());
            }
            // add limm fields, if any
            imemWidth += firstMoveSlotIndex();
            compressedWidth_ = imemWidth;
            setImemWidth(compressedWidth_);
 
            if (Application::verboseLevel() > 0 && dictionary_.size() > 0) {
                printDetails();
            }
        }
        startNewProgram(programName);
        setAllInstructionsToStartAtBeginningOfMAU();
        addInstructions();
        return programBits();
    }

References MathTools::requiredBits(), and Application::verboseLevel().

Here is the call graph for this function:

createDictionary()

void MoveSlotDictionary::createDictionary ( )

inlineprivate

Creates the whole dictionary

Definition at line 162 of file MoveSlotDictionary.cc.

                       {
        for (int i = 0; i < moveSlotCount(); i++) {
            dictionary_.push_back(new Dictionary);
        }
 
        for (int i = 0; i < numberOfPrograms(); i++) {
            TPEFMap::const_iterator iter = programElement(i);
            string name = iter->first;
            startNewProgram(name);
            setAllInstructionsToStartAtBeginningOfMAU();
            updateDictionary(currentProgram());
        }
 
        dictionaryCreated_ = true;
    }

evaluateMoveSlotBoundaries()

void MoveSlotDictionary::evaluateMoveSlotBoundaries ( vector< pair< int, int > > &  boundaries )

inlineprivate

Definition at line 424 of file MoveSlotDictionary.cc.

                                                                        {
        for (int i = 0; i < moveSlotCount(); i++) {
            int temp = 0;
            if (boundaries.size() == 0) {
                temp = firstMoveSlotIndex();
            } else {
                // end point of previous boundary
                temp = boundaries.at(boundaries.size()-1).second;
            }
            int begin = temp + 1;
            int end = temp + MathTools::requiredBits(dictionary_.at(i)->size());
            boundaries.push_back(std::make_pair(begin,end));
        }
    }

References MathTools::requiredBits().

Here is the call graph for this function:

generateDecompressor()

virtual void MoveSlotDictionary::generateDecompressor ( std::ostream &  stream, TCEString  entityStr  )

inlinevirtual

Generates the decompressor in VHDL.

Note! The programs must be compressed by compress method before calling this method.

Parameters

stream

The stream to write.

Implements CodeCompressorPlugin.

Definition at line 131 of file MoveSlotDictionary.cc.

                                                                  {
        generateDictionaryVhdl(stream, entityStr);
        generateDecompressorEntity(stream, entityStr);
        generateDecompressorArchitecture(stream, entityStr);
    }

generateDecompressorArchitecture()

void MoveSlotDictionary::generateDecompressorArchitecture ( std::ostream &  stream, TCEString  entityStr  )

inlineprivate

Definition at line 340 of file MoveSlotDictionary.cc.

                                                 {
        stream << "architecture move_slot_dict of " << entityStr 
               << "_decompressor is" << endl << endl;
 
        bool haveLimm = false;
        generateDecompressorSignals(stream,haveLimm);
        
        generateDecompressorBody(stream, haveLimm);
        
        stream << "end move_slot_dict;" << endl;
    }

generateDecompressorBody()

void MoveSlotDictionary::generateDecompressorBody ( std::ostream &  stream, bool &  haveLimm  )

inlineprivate

Definition at line 391 of file MoveSlotDictionary.cc.

                                                                      {
        stream << indentation(1) << "begin" << endl << endl;
        stream << indentation(1) << "glock <= lock;" << endl;
        stream << indentation(1) << "fetch_en <= not lock_r;" << endl << endl;
 
        
        if (haveLimm) {
            int limmEndIndex = firstMoveSlotIndex();
            stream << indentation(1)
                   << "limm_field <= fetchblock(fetchblock'length-1 downto "
                   << "fetchblock'length-" << limmEndIndex << ");" << endl
                   << endl;
        }
        // pair<beginIndex,endIndex>
        vector<pair<int,int> > moveSlotBoundaries;
        evaluateMoveSlotBoundaries(moveSlotBoundaries);
        
        for (int i = 0; i < moveSlotCount(); i++) {
            if (dictionary_.at(i)->size() > 1) {
                stream << indentation(1)
                       << "dict_line_" << i 
                       << " <= conv_integer(unsigned(fetchblock("
                       << "fetchblock'length-" 
                       << moveSlotBoundaries.at(i).first
                       << " downto fetchblock'length-" 
                       << moveSlotBoundaries.at(i).second
                       << ")));" << endl << endl;
            }
        }
        
        generateDecompressorProcess(stream, haveLimm);
    }

generateDecompressorEntity()

void MoveSlotDictionary::generateDecompressorEntity ( std::ostream &  stream, TCEString  entityStr  )

inlineprivate

Definition at line 314 of file MoveSlotDictionary.cc.

                                                                             {
        // write the decompressor entity
        stream << "library ieee;" << endl;
        stream << "use ieee.std_logic_1164.all;" << endl;
        stream << "use ieee.std_logic_arith.all;" << endl;
        stream << "use work." << entityStr << "_globals.all;" << endl;
        stream << "use work." << entityStr << "_dict_init.all;" << endl;
        stream << "use work." << entityStr << "_imem_mau.all;" << endl << endl;
        
        stream << "entity " << entityStr << "_decompressor is" << endl;
        stream << indentation(1) << "port (" << endl;
        stream << indentation(2) << "fetch_en : out std_logic;" << endl;
        stream << indentation(2) << "lock : in std_logic;" << endl;
        stream << indentation(2)
               << "fetchblock : in std_logic_vector("
               << "IMEMWIDTHINMAUS*IMEMMAUWIDTH-1 downto 0);" << endl;
        stream << indentation(2)
               << "instructionword : out std_logic_vector("
               << "INSTRUCTIONWIDTH-1 downto 0);" << endl;
        stream << indentation(2) << "glock : out std_logic;" << endl;
        stream << indentation(2) << "lock_r : in std_logic;" << endl;
        stream << indentation(2) << "clk : in std_logic;" << endl;
        stream << indentation(2) << "rstx : in std_logic);" << endl << endl;
        stream << "end " << entityStr << "_decompressor;" << endl << endl;
    }

generateDecompressorProcess()

void MoveSlotDictionary::generateDecompressorProcess ( std::ostream &  stream, bool &  haveLimm  )

inlineprivate

Definition at line 439 of file MoveSlotDictionary.cc.

                                                                         {
        stream << indentation(1) << "process (";
        if (haveLimm) {
            stream << "limm_field, ";
        }
        for (int i = 0; i < moveSlotCount(); i++) {
            if (dictionary_.at(i)->size() > 1) {
                stream << "dict_line_" << i;
                if (i+1 < moveSlotCount() 
                    && dictionary_.at(i+1)->size() > 1) {
                    stream << ", ";
                }
            }
        }
        stream << ")" << endl
               << indentation(1) << "begin" << endl
               << indentation(2) << "instructionword <= ";
        if (haveLimm) {
            stream << "limm_field&";
        }
        for (int i = 0; i < moveSlotCount(); i++) {
            if (dictionary_.at(i)->size() > 1) {
                stream << "dict_" << i <<"(dict_line_" << i << ")";
            } else {
                stream << "dict_" << i;
            }
            if (i+1 < moveSlotCount()) {
                stream << "&";
            }
        }
        stream << ";" << endl
               << indentation(1) << "end process;" << endl << endl;
    }

generateDecompressorSignals()

void MoveSlotDictionary::generateDecompressorSignals ( std::ostream &  stream, bool &  haveLimm  )

inlineprivate

Definition at line 353 of file MoveSlotDictionary.cc.

                                                                         {
        // signal types & signals for dictionaries
        for (int i = 0; i < moveSlotCount(); i++) {
            if (dictionary_.at(i)->size() > 1) {
                stream << indentation(1)
                       << "subtype dict_index_"<< i 
                       <<" is integer range 0 to "
                       << "dict_init_slot_" << i 
                       << "'length-1;" << endl;
                stream << indentation(1)
                       << "signal dict_line_" 
                       << i <<" : dict_index_" << i << ";" << endl;
                stream << indentation(1)
                       << "constant dict_" << i 
                       << " : std_logic_dict_matrix_"
                       << i << "(0 to dict_init_slot_" << i 
                       << "'length-1) := dict_init_slot_"
                       << i << ";" << endl << endl;
            } else {
                stream << indentation(1)
                       << "constant dict_" << i
                       << " : std_logic_vector("
                       << moveSlotWidth(i)
                       << "-1 downto 0) := dict_init_slot_"
                       << i << ";" << endl << endl;
            }
        }
        // handle limm fields if present
        int limmEndIndex = 0;
        if (firstMoveSlotIndex() != 0) {
            haveLimm = true;
            limmEndIndex = firstMoveSlotIndex();
            stream << indentation(1)
                   << "signal limm_field : std_logic_vector("
                   << limmEndIndex << "-1 downto 0);" << endl << endl; 
        }
    }

generateDictionaryVhdl()

void MoveSlotDictionary::generateDictionaryVhdl ( std::ostream &  stream, TCEString  entityStr  )

inlineprivate

Definition at line 257 of file MoveSlotDictionary.cc.

                                                                         {
        stream << "library ieee;" << endl;
        stream << "use ieee.std_logic_1164.all;" << endl;
        stream << "use ieee.std_logic_arith.all;" << endl << endl;
        
        TCEString packageName = entityStr + "_dict_init";
 
        stream << "package " << packageName << " is" << endl << endl;
 
        for (int i = 0; i < moveSlotCount(); i++) {
            if (dictionary_.at(i)->size() > 1) {
                stream << indentation(1)
                       << "type std_logic_dict_matrix_" << i 
                       << " is array (natural range <>) "
                       << "of std_logic_vector(" << moveSlotWidth(i)-1
                       << " downto 0);" << endl << endl;
            }
        }
 
        // write the dictionary contents
        for (int i = 0; i < moveSlotCount(); i++) {
            if (dictionary_.at(i)->size() > 1) {
                stream << indentation(1)
                       << "constant dict_init_slot_" << i 
                       << " : std_logic_dict_matrix_" << i << " := (" << endl;
                for (unsigned int j = 0; j < dictionary_.at(i)->size(); j++) {
                    BitVector instr = MapTools::keyForValue<BitVector>(
                        *(dictionary_.at(i)), j);
                    AsciiImageWriter writer(instr, instr.size());
                    stream << indentation(2) << "\"";
                    writer.writeImage(stream);
                    stream << "\"";
                    if (j+1 < dictionary_.at(i)->size()) {
                        stream << "," << endl;
                    } else {
                        stream << ");" << endl;
                    }
                }
            } else {
                // there's always at least 1 instruction in dictionary
                unsigned int index = 0;
                BitVector instr = MapTools::keyForValue<BitVector>(
                        *(dictionary_.at(i)), index);
                AsciiImageWriter writer(instr, instr.size());
                stream << indentation(1)
                       << "constant dict_init_slot_" << i
                       << " : std_logic_vector("
                       << moveSlotWidth(i) << "-1 downto 0) := (" << endl
                       << indentation(2) << "\"";
                writer.writeImage(stream);
                stream << "\");" << endl; 
            }
            stream << endl;
        }
        stream << "end " << packageName << ";" << endl << endl;
    }

References AsciiImageWriter::writeImage().

Here is the call graph for this function:

printDescription()

virtual void MoveSlotDictionary::printDescription ( std::ostream &  stream )

inlinevirtual

Prints the description of the plugin to the given stream.

Parameters

stream

The stream.

Implements CodeCompressorPlugin.

Definition at line 143 of file MoveSlotDictionary.cc.

                                         {
        stream  << "Generates the program image using move slot based "
                << "dictionary compression." << endl << endl 
                << "Warning! This compressor works correctly only when "
                << "there is one instruction per MAU in the final program "
                << "image. That is, the MAU of the address space should be "
                << "the same as the width of the compressed instructions or "
                << "wider. Otherwise jump and call addresses are invalid in "
                << "the code. This compressor creates the dictionary on the "
                << "move slot level." << endl << endl;
    }

printDetails()

void MoveSlotDictionary::printDetails ( )

inlineprivate

Definition at line 473 of file MoveSlotDictionary.cc.

                        {
        int widthInBytes = static_cast<int>(
            std::ceil(compressedWidth_ / 8.0));
        Application::logStream() << "compressed instruction width: "
                                 << compressedWidth_ << " ("
                                 << widthInBytes << " bytes)" << endl;
        std::size_t totalSize = 0;
        for (unsigned int i = 0; i < dictionary_.size(); i++) {
            std::size_t index = static_cast<std::size_t>(i);
            std::size_t keyWidth = 
                MathTools::requiredBits(dictionary_.at(i)->size());
            std::size_t entrySize = binaryEncoding().width();
            std::size_t entries = dictionary_.at(i)->size();
            totalSize += entries * entrySize;
            Application::logStream() 
                << (boost::format(
                        "Dictionary %d:\n"
                        "dictionary width: %d bits, entries: %d, "
                        "dictionary size: %d bits (%d bytes)\n")
                    % index % keyWidth % entries % (entries * entrySize)
                    % std::size_t(
                        std::ceil(entries * entrySize / 8.0))).str();
        }
        Application::logStream() 
            << (boost::format(
                    "Total dictionary size: %d bits (%d bytes)\n\n")
                % totalSize 
                % std::size_t(std::ceil(totalSize / 8.0))).str();
    }

References Application::logStream(), and MathTools::requiredBits().

Here is the call graph for this function:

updateDictionary()

void MoveSlotDictionary::updateDictionary ( const Program &  program )

inlineprivate

Creates dictionary for one program.

Definition at line 182 of file MoveSlotDictionary.cc.

                                             {
        Instruction* instruction = &program.firstInstruction();
        while (instruction != &NullInstruction::instance()) {
            InstructionBitVector* instructionBits = bemInstructionBits(
                *instruction);
            unsigned int begin = firstMoveSlotIndex();
            unsigned int end = begin;
            for (int i = 0; i < moveSlotCount(); i++) {
                end = begin + moveSlotWidth(i) - 1;
                BitVector moveSlot(*instructionBits, begin, end);
                addToDictionary(moveSlot, i);
                begin = end + 1;
            }
            instruction = &program.nextInstruction(*instruction);
            delete instructionBits;
        }   
    }

References program.

Member Data Documentation

compressedWidth_

unsigned int MoveSlotDictionary::compressedWidth_

private

Total width of compressed instruction (limm fields + move slots)

Definition at line 513 of file MoveSlotDictionary.cc.

dictionary_

vector<Dictionary*> MoveSlotDictionary::dictionary_

private

The dictionary.

Definition at line 507 of file MoveSlotDictionary.cc.

dictionaryCreated_

bool MoveSlotDictionary::dictionaryCreated_

private

Indicates whether the dictionary has been created.

Definition at line 510 of file MoveSlotDictionary.cc.

---

The documentation for this class was generated from the following file:

• MoveSlotDictionary.cc