POMValidator Class Reference

#include <POMValidator.hh>

Collaboration diagram for POMValidator:

Public Types
enum	ErrorCode { CONNECTION_MISSING, LONG_IMMEDIATE_NOT_SUPPORTED, SIMULATION_NOT_POSSIBLE, COMPILED_SIMULATION_NOT_POSSIBLE }
	Error codes for different errors. More...

Public Member Functions
	POMValidator (const TTAProgram::Program &program)
virtual	~POMValidator ()
POMValidatorResults *	validate (const std::set< ErrorCode > &errorsToCheck)

Private Member Functions
void	checkConnectivity (POMValidatorResults &results)
void	checkLongImmediates (POMValidatorResults &results)
void	checkSimulatability (POMValidatorResults &results)
void	checkCompiledSimulatability (POMValidatorResults &results)

Private Attributes
const TTAProgram::Program::InstructionVector	instructions_
	The program's instructions in a quickly accessed vector. More...

Detailed Description

POMValidator validates a program object model against a target processor architecture using varoius criteria.

Definition at line 49 of file POMValidator.hh.

Member Enumeration Documentation

ErrorCode

enum POMValidator::ErrorCode

Error codes for different errors.

Enumerator
CONNECTION_MISSING	Connection required for a move is missing.
LONG_IMMEDIATE_NOT_SUPPORTED	Instruction template missing for a long immediate.
SIMULATION_NOT_POSSIBLE	Program contains operations with unknown behaviour.
COMPILED_SIMULATION_NOT_POSSIBLE	Compiled simulation is not possible.

Definition at line 53 of file POMValidator.hh.

                   {
        /// Connection required for a move is missing.
        CONNECTION_MISSING,
        /// Instruction template missing for a long immediate.
        LONG_IMMEDIATE_NOT_SUPPORTED,
        /// Program contains operations with unknown behaviour.
        SIMULATION_NOT_POSSIBLE,
        /// Compiled simulation is not possible
        COMPILED_SIMULATION_NOT_POSSIBLE
    };

Constructor & Destructor Documentation

POMValidator()

POMValidator::POMValidator

(

const TTAProgram::Program &

program

)

The Constructor.

Parameters

program

POM to validate.

Definition at line 61 of file POMValidator.cc.

                                                          :
    instructions_(program.instructionVector()) {
 
}

~POMValidator()

POMValidator::~POMValidator ( )

virtual

The Destructor.

Definition at line 69 of file POMValidator.cc.

                            {
}

Member Function Documentation

checkCompiledSimulatability()

void POMValidator::checkCompiledSimulatability ( POMValidatorResults &  results )

private

Checks for problems specific to compiled simulation only.

Used to check if the program cannot be simulated with the compiled simulator.

Parameters

results

POMValidator results where the error messages are added.

Definition at line 325 of file POMValidator.cc.

                                                                      {    
 
    for (std::size_t instrI = 0; instrI < instructions_.size(); ++instrI) {
        const Instruction* instruction = instructions_.at(instrI);
        for (int i = 0; i < instruction->moveCount(); i++) {
            Move& move = instruction->move(i);
            Terminal* destination = &move.destination();
            // clocked operations
            if (destination->isFUPort()) {
                if (destination->isOpcodeSetting() && 
                    destination->operation().isClocked()) {
                    InstructionAddress address = instruction->address().location();
                    std::string errorMessage =
                        "Instruction at address: " +
                        Conversion::toString(address) +
                        "' cannot be simulated with the compiled simulator. "
                        "(Operation " + destination->operation().name() + 
                        " is a clocked operation).";
                    
                    results.addError(COMPILED_SIMULATION_NOT_POSSIBLE,
                    errorMessage);
                }
            }
        } // end for
    }
}

References POMValidatorResults::addError(), TTAProgram::Instruction::address(), COMPILED_SIMULATION_NOT_POSSIBLE, TTAProgram::Move::destination(), instructions_, Operation::isClocked(), TTAProgram::Terminal::isFUPort(), TTAProgram::Terminal::isOpcodeSetting(), TTAProgram::Address::location(), TTAProgram::Instruction::move(), TTAProgram::Instruction::moveCount(), Operation::name(), TTAProgram::Terminal::operation(), and Conversion::toString().

Referenced by validate().

Here is the call graph for this function:

checkConnectivity()

void POMValidator::checkConnectivity ( POMValidatorResults &  results )

private

Checks if the target machine has connectivity needed for program moves.

Parameters

results

POMValidator results where the error messages are added.

Definition at line 108 of file POMValidator.cc.

                                                            {
 
    for (std::size_t instrI = 0; instrI < instructions_.size(); ++instrI) {
        const Instruction* instruction = instructions_.at(instrI);
        // Test all moves in the current instruction.
        for (int i = 0; i < instruction->moveCount(); i++) {
            const Move& move = instruction->move(i);
 
            const Bus& bus = move.bus();
 
            // Test move source connectivity.
            if (move.source().isGPR() ||
                move.source().isFUPort() ||
                move.source().isImmediateRegister()) {
 
                const Port& port = move.source().port();
 
                if (port.outputSocket() == NULL) {
                    // ERROR: Source port is not connected to an output socket.
                    InstructionAddress address = instruction->address().location();
                    std::string errorMessage =
                        Conversion::toString(address) + ": " +
                        "Source port '" + port.parentUnit()->name() +
                        "." + port.name() + "' of the move on bus '" +
                        bus.name() + "' is not connected to an output socket.";
 
                    results.addError(CONNECTION_MISSING, errorMessage);
 
                } else if (!port.outputSocket()->isConnectedTo(bus)) {
                    // ERROR: Output socket of the source port is not connected
                    // to the move bus.
                    InstructionAddress address = instruction->address().location();
                    std::string errorMessage =
                        Conversion::toString(address) + ": " +
                        "Source port '" + port.parentUnit()->name() +
                        "." + port.name() + "' of the move on bus '" +
                        bus.name() + "' is not connected to the bus.";
                    results.addError(CONNECTION_MISSING, errorMessage);
                }
 
            }
 
            // Test move target connectivity.
            if (move.destination().isGPR() ||
                move.destination().isFUPort() ||
                move.destination().isImmediateRegister()) {
 
                const Port& port = move.destination().port();
 
                if (port.inputSocket() == NULL) {
                    // ERROR: Destination port is not connected to an output
                    // socket.
                    InstructionAddress address = instruction->address().location();
                    std::string errorMessage =
                        Conversion::toString(address) + ": " +
                        "Destination port '" + port.parentUnit()->name() +
                        "." + port.name() + "' of the move on bus '" +
                        bus.name() + "' is not connected to an input socket.";
 
                    results.addError(CONNECTION_MISSING, errorMessage);
 
                } else if (!port.inputSocket()->isConnectedTo(bus)) {
                    // ERROR: Output socket of the target port is not connected
                    // to the move bus.
                    InstructionAddress address = instruction->address().location();
                    std::string errorMessage =
                        Conversion::toString(address) + ": " +
                        "Destination port '" + port.parentUnit()->name() +
                        "." + port.name() + "' of the move on bus '" +
                        bus.name() + "' is not connected to the bus.";
                    results.addError(CONNECTION_MISSING, errorMessage);
                }
 
            }
        }
    }
}

References POMValidatorResults::addError(), TTAProgram::Instruction::address(), TTAProgram::Move::bus(), CONNECTION_MISSING, TTAProgram::Move::destination(), TTAMachine::Port::inputSocket(), instructions_, TTAMachine::Socket::isConnectedTo(), TTAProgram::Terminal::isFUPort(), TTAProgram::Terminal::isGPR(), TTAProgram::Terminal::isImmediateRegister(), TTAProgram::Address::location(), TTAProgram::Instruction::move(), TTAProgram::Instruction::moveCount(), TTAMachine::Port::name(), TTAMachine::Component::name(), TTAMachine::Port::outputSocket(), TTAMachine::Port::parentUnit(), TTAProgram::Terminal::port(), TTAProgram::Move::source(), and Conversion::toString().

Referenced by validate().

Here is the call graph for this function:

checkLongImmediates()

void POMValidator::checkLongImmediates ( POMValidatorResults &  results )

private

Checks long immediate assignments.

Parameters

results

POMValidator results where the error messages are added.

Definition at line 192 of file POMValidator.cc.

                                                              {
 
    for (std::size_t instrI = 0; instrI < instructions_.size(); ++instrI) {
        const Instruction* instruction = instructions_.at(instrI);
 
        const InstructionTemplate& templ =
            instruction->instructionTemplate();
 
        std::set<std::string> destinations;
        for (int i = 0; i < instruction->immediateCount(); i++) {
 
            const Immediate& immediate = instruction->immediate(i);
 
            // Check that the immediate destination terminal is an IU.
            if (!immediate.destination().isImmediateRegister()) {
                InstructionAddress address = instruction->address().location();
                std::string errorMessage =
                    Conversion::toString(address) + ": " +
                    "Long immediate destination terminal is not an "
                    "immediate unit.";
                results.addError(LONG_IMMEDIATE_NOT_SUPPORTED, errorMessage);
                continue;
            }
 
            int width = immediate.value().value().width();
            const ImmediateUnit& iu =
                immediate.destination().immediateUnit();
            int supportedWidth = templ.supportedWidth(iu);
            if (width <= INT_WORD_SIZE &&                 
                supportedWidth != width) {
                // Raw magic! If the SimValue reports width higher then
                // INT_WORD_SIZE it means immediate is floating point,
                // and should be just respected:-)
                // If width is less, the actuall width is recomputed
                // based on target as if it was integer
                // FIXME: find out how to deal with floating point
                if (iu.extensionMode() == Machine::ZERO) {
                    // Actual required width depends on target immediate unit
                    width = MathTools::requiredBits(
                        immediate.value().value().unsignedValue());
                } 
                if (iu.extensionMode() == Machine::SIGN) {
                    // Actual required width depends on target immediate unit
                    width = MathTools::requiredBitsSigned(
                        immediate.value().value().intValue());
                }
            }
            // Check that the destination IU isn't already destination
            // of a long immediate in the current instruction.
            std::pair<std::set<std::string>::iterator, bool> result =
                destinations.insert(iu.name());
 
            if (!result.second) {
                // Destination already in the set.
                InstructionAddress address = instruction->address().location();
                std::string errorMessage =
                    Conversion::toString(address) + ": " +
                    "Multiple long immediates with destination IU '" +
                    iu.name() + "'.";
                results.addError(LONG_IMMEDIATE_NOT_SUPPORTED, errorMessage);
                continue;
            }
 
            // Check that the instruction template supports long immediates
            // with the current long immediate's width and destination IU.
            if (supportedWidth < width) {
                InstructionAddress address = instruction->address().location();
                std::string errorMessage =
                    Conversion::toString(address) + ": " +
                    "Long immediate with destination IU '" +
                    iu.name() + "' has width of " +
                    Conversion::toString(width) + " bits. Instruction's " +
                    "template only supports long immediates with width of " +
                    Conversion::toString(templ.supportedWidth(iu)) +
                    " bits or less. For template " + templ.name();
                results.addError(LONG_IMMEDIATE_NOT_SUPPORTED, errorMessage);
                continue;
            }
        }
    }
}

References POMValidatorResults::addError(), TTAProgram::Instruction::address(), TTAProgram::Immediate::destination(), TTAMachine::ImmediateUnit::extensionMode(), TTAProgram::Instruction::immediate(), TTAProgram::Instruction::immediateCount(), TTAProgram::Terminal::immediateUnit(), instructions_, TTAProgram::Instruction::instructionTemplate(), INT_WORD_SIZE, SimValue::intValue(), TTAProgram::Terminal::isImmediateRegister(), TTAProgram::Address::location(), LONG_IMMEDIATE_NOT_SUPPORTED, TTAMachine::Component::name(), MathTools::requiredBits(), MathTools::requiredBitsSigned(), TTAMachine::InstructionTemplate::supportedWidth(), Conversion::toString(), SimValue::unsignedValue(), TTAProgram::TerminalImmediate::value(), TTAProgram::Immediate::value(), and SimValue::width().

Referenced by validate().

Here is the call graph for this function:

checkSimulatability()

void POMValidator::checkSimulatability ( POMValidatorResults &  results )

private

Checks that all operations in the program have known behaviour and can be simulated.

Parameters

results

POMValidator results where the error messages are added.

Definition at line 281 of file POMValidator.cc.

                                                              {
    
    std::set<std::string> errOpNames;
 
    for (std::size_t instrI = 0; instrI < instructions_.size(); ++instrI) {
        const Instruction* instruction = instructions_.at(instrI);
 
        for (int i = 0; i < instruction->moveCount(); i++) {
            Move& move = instruction->move(i);
            Terminal* destination = &move.destination();
            if (destination->isFUPort()) {
                if (destination->isOpcodeSetting() &&
                    !destination->operation().canBeSimulated() &&
                    !ContainerTools::containsValue(
                        errOpNames, destination->operation().name())) {
 
                    std::string opName =  destination->operation().name();
                    InstructionAddress address =
                        instruction->address().location();
 
                    std::string errorMessage =
                        Conversion::toString(address) + ": " +
                        "Operation '" + opName +
                        "' cannot be simulated.";
 
                    results.addError(
                            SIMULATION_NOT_POSSIBLE, errorMessage);
 
                    errOpNames.insert(opName);
                }
            }
        }
    }
}

References POMValidatorResults::addError(), TTAProgram::Instruction::address(), Operation::canBeSimulated(), ContainerTools::containsValue(), TTAProgram::Move::destination(), instructions_, TTAProgram::Terminal::isFUPort(), TTAProgram::Terminal::isOpcodeSetting(), TTAProgram::Address::location(), TTAProgram::Instruction::move(), TTAProgram::Instruction::moveCount(), Operation::name(), TTAProgram::Terminal::operation(), SIMULATION_NOT_POSSIBLE, and Conversion::toString().

Referenced by validate().

Here is the call graph for this function:

validate()

POMValidatorResults * POMValidator::validate

(

const std::set< ErrorCode > &

errorsToCheck

)

Checks the program against the target machine for given error check set.

Parameters

errorsToCheck

Set of error codes which are checked.

Returns

POMValidatorResults object contaning possible error messages.

Definition at line 79 of file POMValidator.cc.

                                                             {
 
    POMValidatorResults* results = new POMValidatorResults();
    for (std::set<ErrorCode>::const_iterator iter = errorsToCheck.begin();
         iter != errorsToCheck.end(); iter++) {
        ErrorCode code = *iter;
        if (code == CONNECTION_MISSING) {
            checkConnectivity(*results);
        } else if (code == LONG_IMMEDIATE_NOT_SUPPORTED) {
            checkLongImmediates(*results);
        } else if (code == SIMULATION_NOT_POSSIBLE) {
            checkSimulatability(*results);
        } else if (code == COMPILED_SIMULATION_NOT_POSSIBLE) {
            checkCompiledSimulatability(*results);
        } else {
            assert(false);
        }
    }
 
    return results;
}

References assert, checkCompiledSimulatability(), checkConnectivity(), checkLongImmediates(), checkSimulatability(), COMPILED_SIMULATION_NOT_POSSIBLE, CONNECTION_MISSING, LONG_IMMEDIATE_NOT_SUPPORTED, and SIMULATION_NOT_POSSIBLE.

Referenced by SimulatorFrontend::loadProgram().

Here is the call graph for this function:

Member Data Documentation

instructions_

const TTAProgram::Program::InstructionVector POMValidator::instructions_

private

The program's instructions in a quickly accessed vector.

Definition at line 76 of file POMValidator.hh.

Referenced by checkCompiledSimulatability(), checkConnectivity(), checkLongImmediates(), and checkSimulatability().

---

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

• POMValidator.hh
• POMValidator.cc