InstructionDictionary Class Reference

Inheritance diagram for InstructionDictionary:

Collaboration diagram for InstructionDictionary:

Public Member Functions
	InstructionDictionary ()
virtual InstructionBitVector *	compress (const std::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	addToDictionary (const BitVector &instructionBits)
void	updateDictionary (const Program &program)
void	addInstructions ()

Private Attributes
Dictionary	dictionary_
	The dictionary. More...
bool	compatibilityProgDone_
	Indicates whether the compatibility program is in dictionary. More...
bool	dictionaryCreated_
	Indicates whether the whole dictionary has been created. 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

Implements a simple instruction based dictionary compression scheme.

Definition at line 78 of file InstructionDictionary.cc.

Member Typedef Documentation

Dictionary

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

private

Map type for dictionary.

Definition at line 251 of file InstructionDictionary.cc.

Constructor & Destructor Documentation

InstructionDictionary()

InstructionDictionary::InstructionDictionary ( )

inline

The constructor.

Definition at line 84 of file InstructionDictionary.cc.

                            :
        CodeCompressorPlugin(), compatibilityProgDone_(false),
        dictionaryCreated_(false) {
    }

Member Function Documentation

addInstructions()

void InstructionDictionary::addInstructions ( )

inlineprivate

Adds the compressed instructions to the program.

Definition at line 315 of file InstructionDictionary.cc.

                      {
        Instruction* instruction = &currentProgram().firstInstruction();
        while (instruction != &NullInstruction::instance()) {
            InstructionBitVector* bemBits = bemInstructionBits(*instruction);
            unsigned int code = MapTools::valueForKey<unsigned int>(
                dictionary_, *bemBits);
            InstructionBitVector* compressedInstruction = 
                new InstructionBitVector();
            static_cast<BitVector*>(compressedInstruction)->pushBack(
                code, static_cast<int>(
                    MathTools::requiredBits(dictionary_.size() - 1)));
            addInstruction(*instruction, compressedInstruction);
            instruction = &currentProgram().nextInstruction(*instruction);  
            
        }
    }

References MathTools::requiredBits().

Here is the call graph for this function:

addToDictionary()

void InstructionDictionary::addToDictionary ( const BitVector &  instructionBits )

inlineprivate

Adds the given instruction bits to the dictionary.

Parameters

instructionBits

The instruction bits to add.

Definition at line 287 of file InstructionDictionary.cc.

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

References MapTools::containsKey().

Here is the call graph for this function:

compress()

virtual InstructionBitVector* InstructionDictionary::compress ( const std::string &  programName )

inlinevirtual

Creates the compressed code and returns the bit vector of it.

Implements CodeCompressorPlugin.

Definition at line 94 of file InstructionDictionary.cc.

                                           {
        try {
            if (hasParameter(ENSURE_PROGRAMMABILITY) &&
                parameterValue(ENSURE_PROGRAMMABILITY) == YES && 
                !compatibilityProgDone_) {
                ProgrammabilityValidator validator(machine());
                ProgrammabilityValidatorResults results;
                Binary* compatibilityBin = validator.profile(results);
                TPEFProgramFactory factory(*compatibilityBin, machine());
                Program* compatibilityProg = factory.build();
                updateDictionary(*compatibilityProg);
                delete compatibilityBin;
                delete compatibilityProg;
                compatibilityProgDone_ = true;
            }
        } catch (const Exception& e) {
            string errorMsg = "Unable to ensure programmability: " + 
                e.errorMessage();
            throw InvalidData(
                __FILE__, __LINE__, __func__, errorMsg);
        }            
        if (!dictionaryCreated_) {
            createDictionary();
 
            unsigned int compressedImemWidth = 
                MathTools::requiredBits(dictionary_.size());
            assert(compressedImemWidth <= sizeof(long long unsigned int)*8
                   && "Compressed instruction width is too big");
 
            // fix imem width (mau == instruction width)
            setImemWidth(compressedImemWidth);
        }
        startNewProgram(programName);
        setAllInstructionsToStartAtBeginningOfMAU();
        addInstructions();
        return programBits();
    }

References __func__, assert, TTAProgram::TPEFProgramFactory::build(), ENSURE_PROGRAMMABILITY, Exception::errorMessage(), machine, ProgrammabilityValidator::profile(), MathTools::requiredBits(), and YES.

Here is the call graph for this function:

createDictionary()

void InstructionDictionary::createDictionary ( )

inlineprivate

Creates the whole dictionary

Definition at line 258 of file InstructionDictionary.cc.

                       {
        for (int i = 0; i < numberOfPrograms(); i++) {
            TPEFMap::const_iterator iter = programElement(i);
            string name = iter->first;
            startNewProgram(name);
            setAllInstructionsToStartAtBeginningOfMAU();
            updateDictionary(currentProgram());
        }
        dictionaryCreated_ = true;
        if (Application::verboseLevel() > 0 && dictionary_.size() > 0) {
            std::size_t keyWidth = 
                MathTools::requiredBits(dictionary_.size() - 1);
            std::size_t entrySize = binaryEncoding().width();
            std::size_t entries = dictionary_.size();
            Application::logStream() 
                << (boost::format(                    
                        "dictionary width: %d bits, entries: %d, "
                        "total size: %d bits (%d bytes)\n" )
                    % keyWidth % entries % (entries * entrySize)
                    % std::size_t(std::ceil(entries * entrySize / 8.0))).str();
        }
    }

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

Here is the call graph for this function:

generateDecompressor()

virtual void InstructionDictionary::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 141 of file InstructionDictionary.cc.

                                                                  {
 
        stream << "library ieee;" << endl;
        stream << "use ieee.std_logic_1164.all;" << endl;
        stream << "use ieee.std_logic_arith.all;" << endl << endl;
        
        stream << "package " << entityStr << "_dict_init is" << endl << endl;
        stream << indentation(1)
               << "type std_logic_dict_matrix is array (natural range <>) "
               << "of std_logic_vector(" << binaryEncoding().width() - 1
               << " downto 0);" << endl << endl;
        
        // write the dictionary contents
        stream << indentation(1)
               << "constant dict_init : std_logic_dict_matrix := (" << endl;
        for (unsigned int i = 0; i < dictionary_.size(); i++) {
            BitVector instr = MapTools::keyForValue<BitVector>(
                dictionary_, i);
            AsciiImageWriter writer(instr, instr.size());
            stream << indentation(2) << "\"";
            writer.writeImage(stream);
            stream << "\"";
            if (i+1 < dictionary_.size()) {
                stream << "," << endl;
            } else {
                stream << ");" << endl;
            }
        }
        stream << "end " << entityStr << "_dict_init;" << endl << endl;
 
        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;
     
        // write the decompressor entity
        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;
 
        stream << "architecture simple_dict of " << entityStr 
               << "_decompressor is" << endl << endl;
 
        stream << indentation(1)
               << "subtype dict_index is integer range 0 to "
               << "dict_init'length-1;" << endl;
        stream << indentation(1) << "signal dict_line : dict_index;" << endl;
        stream << indentation(1)
               << "constant dict : std_logic_dict_matrix("
               << "0 to dict_init'length-1) := dict_init;" << endl << endl;
 
        stream << "begin" << endl << endl;
        stream << indentation(1) << "glock <= lock;" << endl;
        stream << indentation(1) << "fetch_en <= not lock_r;" << endl;
        stream << indentation(1)
               << "dict_line <= conv_integer(unsigned(fetchblock("
               << "fetchblock'length-1 downto fetchblock'length-"
               << MathTools::requiredBits(dictionary_.size()-1)
               << ")));" << endl << endl;
        
        stream << indentation(1) << "process (dict_line)" << endl;
        stream << indentation(1) << "begin" << endl;
        stream << indentation(2) << "instructionword <= dict(dict_line);"
               << endl;
        stream << indentation(1) << "end process;" << endl << endl;
        stream << "end simple_dict;" << endl;
    }

References MathTools::requiredBits(), and AsciiImageWriter::writeImage().

Here is the call graph for this function:

printDescription()

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

inlinevirtual

Prints the description of the plugin to the given stream.

Parameters

stream

The stream.

Implements CodeCompressorPlugin.

Definition at line 230 of file InstructionDictionary.cc.

                                         {
        stream  << "Generates the program image using instruction-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 minimum addressable unit 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 "
                << "level of whole instruction." << endl << endl
                << "Parameters accepted:" << endl
                << "----------------------" << endl
                << "ensure_programmability" << endl
                << "If the value is 'yes', instructions that ensure "
                << "programmability of the processor are added to the "
                << "dictionary automatically." << endl;
    }

updateDictionary()

void InstructionDictionary::updateDictionary ( const Program &  program )

inlineprivate

Creates the dictionary.

Definition at line 300 of file InstructionDictionary.cc.

                                             {        
        Instruction* instruction = &program.firstInstruction();
        while (instruction != &NullInstruction::instance()) {
            InstructionBitVector* instructionBits = bemInstructionBits(
                *instruction);
            addToDictionary(*instructionBits);
            instruction = &program.nextInstruction(*instruction);
        }   
    }

References program.

Member Data Documentation

compatibilityProgDone_

bool InstructionDictionary::compatibilityProgDone_

private

Indicates whether the compatibility program is in dictionary.

Definition at line 337 of file InstructionDictionary.cc.

dictionary_

Dictionary InstructionDictionary::dictionary_

private

The dictionary.

Definition at line 335 of file InstructionDictionary.cc.

dictionaryCreated_

bool InstructionDictionary::dictionaryCreated_

private

Indicates whether the whole dictionary has been created.

Definition at line 339 of file InstructionDictionary.cc.

---

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

• InstructionDictionary.cc