ProgrammabilityValidator Class Reference

#include <ProgrammabilityValidator.hh>

Collaboration diagram for ProgrammabilityValidator:

Classes
struct	Connections
	Struct of connections. More...
struct	ConnectionSet
	Moves are generated from these. More...

Public Types
enum	ErrorCode {   OPERATION_MISSING_FROM_THE_PRIMITIVE_OPERATION_SET , BOOLEAN_REGISTER_ERROR , BOOLEAN_REGISTER_GUARD_MISSING , GLOBAL_CONNECTION_REGISTER_NOT_FOUND ,   MISSING_CONNECTION }
	Error codes for different errors. More...

Public Member Functions
	ProgrammabilityValidator (const Machine &machine)
	~ProgrammabilityValidator ()
ProgrammabilityValidatorResults *	validate ()
ProgrammabilityValidatorResults *	validate (const std::set< ErrorCode > &errorsToCheck)
void	checkPrimitiveSet (ProgrammabilityValidatorResults &results) const
void	findConnections ()
void	printConnections ()
void	printRegisterConnections ()
const RegisterFile *	findGlobalConnectionRegister ()
void	findGlobalRegisterConnections ()
void	printNotConnectedSockets (const RegisterFile *rf)
void	searchMissingRFConnections (const RegisterFile *rf, vector< pair< string, string > > &toConnections, vector< pair< string, string > > &fromConnections)
bool	checkBooleanRegister (ProgrammabilityValidatorResults &results)
TPEF::Binary *	profile (ProgrammabilityValidatorResults &results)

Private Types
typedef map< string, map< constSocket *, Connections > >::iterator	mapIter
	type definition for going through connection maps
typedef set< pair< constPort *, constPort * > >::iterator	portSetIter
	type definition for going through connection sets
typedef set< pair< constRegisterFile *, constRegisterFile * > >::iterator	registerRegisterSetIter
typedef set< pair< constPort *, constRegisterFile * > >::iterator	portRegisterSetIter
typedef set< pair< constRegisterFile *, constPort * > >::iterator	registerPortSetIter

Private Member Functions
void	addConnectionToProgram (const Port *sourcePort, const Port *destPort, Segment *segment, int &counter)
void	addConnections (set< Segment * > &newConnections, set< Segment * > &connections)
void	addOperationConnections (const FunctionUnit *fu, set< HWOperation * > &operations)
void	listConnections (set< Segment * > &connections, const Socket *socket)
void	printConnection (const Port *sourcePort, const Port *destPort, Segment *segment, int &counter)
void	findRegisterGuard (Segment *segment, RegisterGuard *&guard)
void	addDirectConnection (const Port *sourcePort, const Port *destPort, Segment *segment)
void	addGlobalRegisterConnection (const Port *sourcePort, const Port *destPort, Segment *segment)
void	addDirectConnectionsToProgram ()
void	addGlobalRegisterConnectionsToProgram ()

Private Attributes
const Machine &	machine_
	the target machine
Program *	program_
	Program where moves are generated.
Procedure *	procedure_
	Procedure of the program.
RegisterFile *	booleanRegister_
	Boolean register file of the machine.
RegisterFile *	globalConnectionRegister_
	The global connection register of the machine.
MinimalOpSetCheck *	minimalOpSetCheck_
	Minimal operation checker.
vector< pair< const Port *, set< Segment * > > >	inputs
	All inputs found in the machine are stored here.
int	directCounter
	The counter of direct connections added to the program.
int	gcrCounter
	The counter of global register file connections added to the program.
set< pair< const Port *, const Port * > >	allConnections
	Set of connections to ensure that same Move is not done in multiple buses.
set< pair< const Port *, const Port * > >	gcrConnections
set< pair< const Port *, const RegisterFile * > >	portRegisterConnections
	Set of unit connections to ensure that only one connection per register file is added.
set< pair< const RegisterFile *, const Port * > >	registerPortConnections
set< pair< const RegisterFile *, const RegisterFile * > >	registerRegisterConnections
set< pair< const Port *, const RegisterFile * > >	portGcrConnections
set< pair< const RegisterFile *, const Port * > >	gcrPortConnections
set< pair< const RegisterFile *, const RegisterFile * > >	gcrRegisterConnections
vector< ConnectionSet >	directConnections
	Storage of all the Moves that are found in the machine.
vector< ConnectionSet >	globalRegisterConnections
	Storage of all Moves to and from the Global Connection Register.
map< string, map< const Socket *, Connections > >	FUConnections
	Function unit connections.
map< string, map< const Socket *, Connections > >	GCUConnections
	Global control unit connections.
map< string, map< const Socket *, Connections > >	RFConnections
	Register file connections.
map< string, map< const Socket *, Connections > >	IMMConnections
	Immediate unit connections.

Detailed Description

Definition at line 75 of file ProgrammabilityValidator.hh.

Member Typedef Documentation

mapIter

typedef map<string,map<constSocket*,Connections>>::iterator ProgrammabilityValidator::mapIter

private

type definition for going through connection maps

Definition at line 221 of file ProgrammabilityValidator.hh.

portRegisterSetIter

typedef set<pair<constPort*,constRegisterFile*>>::iterator ProgrammabilityValidator::portRegisterSetIter

private

Definition at line 225 of file ProgrammabilityValidator.hh.

portSetIter

typedef set<pair<constPort*,constPort*>>::iterator ProgrammabilityValidator::portSetIter

private

type definition for going through connection sets

Definition at line 223 of file ProgrammabilityValidator.hh.

registerPortSetIter

typedef set<pair<constRegisterFile*,constPort*>>::iterator ProgrammabilityValidator::registerPortSetIter

private

Definition at line 226 of file ProgrammabilityValidator.hh.

registerRegisterSetIter

typedef set<pair<constRegisterFile*,constRegisterFile*>>::iterator ProgrammabilityValidator::registerRegisterSetIter

private

Definition at line 224 of file ProgrammabilityValidator.hh.

Member Enumeration Documentation

ErrorCode

enum ProgrammabilityValidator::ErrorCode

Error codes for different errors.

Enumerator
OPERATION_MISSING_FROM_THE_PRIMITIVE_OPERATION_SET	Machine don't have all the operations needed to support ANSI C.
BOOLEAN_REGISTER_ERROR	Machine should have one and only one boolean register.
BOOLEAN_REGISTER_GUARD_MISSING	Bus is missing a boolean register file guard.
GLOBAL_CONNECTION_REGISTER_NOT_FOUND	Global connection register could not be determined.
MISSING_CONNECTION	Connection is missing to or from the global connection register.

Definition at line 79 of file ProgrammabilityValidator.hh.

                   {
        /// Machine don't have all the operations needed to support ANSI C.
        OPERATION_MISSING_FROM_THE_PRIMITIVE_OPERATION_SET,
        /// Machine should have one and only one boolean register.
        BOOLEAN_REGISTER_ERROR,
        /// Bus is missing a boolean register file guard.
        BOOLEAN_REGISTER_GUARD_MISSING,
        /// Global connection register could not be determined.
        GLOBAL_CONNECTION_REGISTER_NOT_FOUND,
        /// Connection is missing to or from the global connection register
        MISSING_CONNECTION
    };

Constructor & Destructor Documentation

ProgrammabilityValidator()

ProgrammabilityValidator::ProgrammabilityValidator

(

const Machine &

machine

)

The constructor.

Parameters

machine	The machine that will be profiled.
procedure	ProgrammabilityValidator generates procedure.

Definition at line 78 of file ProgrammabilityValidator.cc.

    : machine_(machine), minimalOpSetCheck_(new MinimalOpSetCheck()) {
    directCounter = 0;
    gcrCounter = 0;
    booleanRegister_ = NULL;
    MachineValidator machineValidator(machine);
    set<MachineValidator::ErrorCode> errorsToCheck;
    errorsToCheck.insert(MachineValidator::GCU_MISSING);
    errorsToCheck.insert(MachineValidator::GCU_AS_MISSING);
 
    MachineValidatorResults* results = 
        machineValidator.validate(errorsToCheck);
 
    for (int i = 0; i < results->errorCount(); i++) {
        MachineValidator::ErrorCode code = results->error(i).first;
        if (code == MachineValidator::GCU_MISSING) {
            string msg = "ADF file doesn't have a GCU.";
            throw IllegalMachine(__FILE__, __LINE__, __func__, msg);
       }
        if (code == MachineValidator::GCU_AS_MISSING) {
            string msg = "No address space bound to GCU.";
            throw IllegalMachine(__FILE__, __LINE__, __func__, msg);
        }
    }
    delete results;
 
    AddressSpace* space = machine_.controlUnit()->addressSpace();
    program_ = new Program(*space);
    procedure_ = new Procedure("programmabilityValidator", *space);
    program_->addProcedure(procedure_);
    
    FUConnections.clear();
    GCUConnections.clear();
    RFConnections.clear();
    IMMConnections.clear();
}

References __func__, TTAProgram::Program::addProcedure(), TTAMachine::FunctionUnit::addressSpace(), booleanRegister_, TTAMachine::Machine::controlUnit(), directCounter, MachineValidatorResults::error(), MachineValidatorResults::errorCount(), FUConnections, gcrCounter, MachineValidator::GCU_AS_MISSING, MachineValidator::GCU_MISSING, GCUConnections, IMMConnections, machine, machine_, procedure_, program_, RFConnections, and MachineValidator::validate().

Here is the call graph for this function:

~ProgrammabilityValidator()

ProgrammabilityValidator::~ProgrammabilityValidator

(

)

The destructor.

Definition at line 118 of file ProgrammabilityValidator.cc.

                                                    {
 
    FUConnections.clear();
    GCUConnections.clear();
    RFConnections.clear();
    IMMConnections.clear();
    delete minimalOpSetCheck_;
    minimalOpSetCheck_ = NULL;
}

References FUConnections, GCUConnections, IMMConnections, minimalOpSetCheck_, and RFConnections.

Member Function Documentation

addConnections()

void ProgrammabilityValidator::addConnections ( set< Segment * > &  newConnections, set< Segment * > &  connections  )

private

Adds new connections to all connections holding set.

Parameters

newConnections	New connections that can be added.
connections	All connections holding set.

Definition at line 1219 of file ProgrammabilityValidator.cc.

                                {
    
    set<Segment*>::iterator i = newConnections.begin();
    for (; i != newConnections.end(); i++) {
        connections.insert(*i);
    }
}

Referenced by findConnections().

addConnectionToProgram()

void ProgrammabilityValidator::addConnectionToProgram ( const Port *  sourcePort, const Port *  destPort, Segment *  segment, int &  counter  )

private

Adds connection to program. Generates instruction that is given to procedure.

Parameters

sourcePort	The source port of the connection.
destPort	The destination port of the connection.
segment	The segment which is used in the connection.
counter	Counter that is updated when an instruction is added.

Definition at line 609 of file ProgrammabilityValidator.cc.

                  {
 
    const Unit* sourceUnit = sourcePort->parentUnit();
    const Unit* destUnit = destPort->parentUnit();
    const BaseRegisterFile* destRF = 
        dynamic_cast<const BaseRegisterFile*>(destUnit);
    const BaseRegisterFile* sourceRF = 
        dynamic_cast<const BaseRegisterFile*>(sourceUnit);
    const FunctionUnit* destFU = dynamic_cast<const FunctionUnit*>(destUnit);
    const FunctionUnit* sourceFU = 
        dynamic_cast<const FunctionUnit*>(sourceUnit);
    const BaseFUPort* destBaseFUPort = 
        dynamic_cast<const BaseFUPort*>(destPort);
    const BaseFUPort* sourceBaseFUPort = 
        dynamic_cast<const BaseFUPort*>(sourcePort);
    
    if (sourceFU != 0) {
        // move is from FU or GCU
        if (sourceBaseFUPort->isTriggering()) {
            // move is from trigger port
            // this is not supported
            return;
        }
        // else
        // move is from FUPort
        
        if (destFU != 0) {
            // move is to FU or GCU
            const FUPort* destFUPort = 
                dynamic_cast<const FUPort*>(destBaseFUPort);
 
            if (destBaseFUPort->isTriggering()) {
                // move is to FU of CGU trigger port
                
                for (int n = 0; n < destFU->operationCount(); n++) {
                    counter++;
                    HWOperation* destOperation = destFU->operation(n);
                    Instruction* instruction = 
                        new Instruction(NullInstructionTemplate::instance());
                    int destOperand = destOperation->io(*destFUPort);
                    Terminal* source = 
                        new TerminalFUPort(*sourceBaseFUPort);
                    Terminal* destination = 
                        new TerminalFUPort(*destOperation, destOperand);
                    RegisterGuard* guard;
                    findRegisterGuard(segment, guard);
                    MoveGuard* moveGuard = new MoveGuard(*guard);
                    auto move = std::make_shared<Move>(source,
                                          destination,
                                          *segment->parentBus(),
                                                   moveGuard);
                    instruction->addMove(move);
                    procedure_->add(instruction);
                }
 
            }
            else {
                // move is to FUPort or Special register port
                // move is to FUPort
                counter++;
                Instruction* instruction = 
                    new Instruction(NullInstructionTemplate::instance());
                Terminal* source = 
                    new TerminalFUPort(*sourceBaseFUPort);
                Terminal* destination = 
                    new TerminalFUPort(*destBaseFUPort);
                RegisterGuard* guard;
                findRegisterGuard(segment, guard);
                MoveGuard* moveGuard = new MoveGuard(*guard);
                auto move = std::make_shared<Move>(source,
                                      destination,
                                      *segment->parentBus(),
                                                  moveGuard);
                instruction->addMove(move);
                procedure_->add(instruction);
            }
        }
        else { //if (destRF != 0)
            // move is to RF
            for (int i = 0; i < destRF->numberOfRegisters(); i++) {
                Instruction* instruction
                    = new Instruction(NullInstructionTemplate::instance());
                Terminal* source = new TerminalFUPort(*sourceBaseFUPort);
                Terminal* destination = new TerminalRegister(*destPort, i);
                RegisterGuard* guard;
                findRegisterGuard(segment, guard);
                MoveGuard* moveGuard = new MoveGuard(*guard);
                auto move = std::make_shared<Move>(source,
                                      destination,
                                      *segment->parentBus(),
                                                        moveGuard);
                instruction->addMove(move);
                procedure_->add(instruction);
                counter++;
            }
        }
    }
    else if (sourceRF != 0) {
        // move is from RF or IMM
        for (int i = 0; i < sourceRF->numberOfRegisters(); i++) {
            if (destFU != 0) {
                // move is to FU or GCU
                if (destBaseFUPort->isTriggering()) {
                    // move is to FU of CGU trigger port
                    const FUPort* destFUPort = 
                        dynamic_cast<const FUPort*>(destBaseFUPort);
                    for (int n = 0; n < destFU->operationCount(); n++) {
                        
                        counter++;
                        HWOperation* destOperation = destFU->operation(n);
                        Instruction* instruction =
                            new Instruction(
                                NullInstructionTemplate::instance());
                        int destOperand = destOperation->io(*destFUPort);
                        Terminal* source = 
                            new TerminalRegister(*sourcePort, i);
                        Terminal* destination = 
                            new TerminalFUPort(*destOperation, destOperand);
                        RegisterGuard* guard;
                        findRegisterGuard(segment, guard);
                        MoveGuard* moveGuard = new MoveGuard(*guard);
                        auto move = std::make_shared<Move>(source,
                                              destination,
                                              *segment->parentBus(),
                                                               moveGuard);
                        instruction->addMove(move);
                        procedure_->add(instruction);
                    }                
                }
                else {
                    // move is to FUPort or Special register port
                    
                    counter++;
                    Instruction* instruction =
                        new Instruction(NullInstructionTemplate::instance());
                    Terminal* source = 
                        new TerminalRegister(*sourcePort, i);
                    Terminal* destination = 
                        new TerminalFUPort(*destBaseFUPort);
                    RegisterGuard* guard;
                    findRegisterGuard(segment, guard);
                    MoveGuard* moveGuard = new MoveGuard(*guard);
                    auto move = std::make_shared<Move>(source,
                                          destination,
                                          *segment->parentBus(),
                                                      moveGuard);
                    instruction->addMove(move);
                    procedure_->add(instruction);
                }
            }
            else { //if (destRF != 0)
                // move is to RF
                for (int j = 0; j < destRF->numberOfRegisters(); j++) {
                    counter++;
                    Instruction* instruction =
                        new Instruction(NullInstructionTemplate::instance());
                    Terminal* source = 
                        new TerminalRegister(*sourcePort, i);
                    Terminal* destination = 
                        new TerminalRegister(*destPort, j);
                    RegisterGuard* guard;
                    findRegisterGuard(segment, guard);
                    MoveGuard* moveGuard = new MoveGuard(*guard);
                    auto move = std::make_shared<Move>(source,
                                          destination,
                                          *segment->parentBus(),
                                                      moveGuard);
                    instruction->addMove(move);
                    procedure_->add(instruction);
                }
            }
        }
    }
}

References TTAProgram::Procedure::add(), TTAProgram::Instruction::addMove(), findRegisterGuard(), TTAMachine::NullInstructionTemplate::instance(), TTAMachine::HWOperation::io(), TTAMachine::BaseFUPort::isTriggering(), TTAMachine::BaseRegisterFile::numberOfRegisters(), TTAMachine::FunctionUnit::operation(), TTAMachine::FunctionUnit::operationCount(), TTAMachine::Segment::parentBus(), TTAMachine::Port::parentUnit(), and procedure_.

Referenced by addDirectConnectionsToProgram(), and addGlobalRegisterConnectionsToProgram().

Here is the call graph for this function:

addDirectConnection()

void ProgrammabilityValidator::addDirectConnection ( const Port *  sourcePort, const Port *  destPort, Segment *  segment  )

private

Adds direct connection (unit to unit) to list of direct connections. Moves can be genetated from these connections.

Parameters

sourcePort	Source port of the move.
destPort	Destionation port of the move.
segment	The segment of the move.

Definition at line 1687 of file ProgrammabilityValidator.cc.

                      {
 
    pair<const Port*, const Port*>  connectionPair = 
        pair<const Port*, const Port*>(sourcePort, destPort);
    pair<portSetIter, bool> result = allConnections.insert(connectionPair);
    // If the insertion was made the connection
    // can be added and it is unique.
    if (result.second) {
        
        // Find out if the source or destination unit is Register File.
        // Only one connection per port to RF and from RF to port is needed.
        const Unit* destUnit = destPort->parentUnit();
        const RegisterFile* destRegister =
            dynamic_cast<const RegisterFile*>(destUnit);
        const Unit* sourceUnit = sourcePort->parentUnit();
        const RegisterFile* sourceRegister =
            dynamic_cast<const RegisterFile*>(sourceUnit);
 
        if (destRegister != NULL) {
            if (sourceRegister != NULL) {
                pair<const RegisterFile*,
                    const RegisterFile*> registerRegisterPair =
                    pair<const RegisterFile*, const RegisterFile*>(
                        sourceRegister, destRegister);
                pair<registerRegisterSetIter, bool> registerRegisterResult = 
                    registerRegisterConnections.insert(registerRegisterPair);
                if (registerRegisterResult.second) {
                    ConnectionSet newSet;
                    newSet.sourcePort = sourcePort;
                    newSet.destPort = destPort;
                    newSet.segment = segment;
                    directConnections.push_back(newSet);
                }
            } else {
                // destination is a register but source is not
                pair<const Port*, const RegisterFile*> portRegisterPair =
                    pair<const Port*, const RegisterFile*>(
                        sourcePort, destRegister);
                pair<portRegisterSetIter, bool> portRegisterResult = 
                    portRegisterConnections.insert(portRegisterPair);
                if (portRegisterResult.second) {
                    ConnectionSet newSet;
                    newSet.sourcePort = sourcePort;
                    newSet.destPort = destPort;
                    newSet.segment = segment;
                    directConnections.push_back(newSet);
                }
            }
        } else if (sourceRegister != NULL) {
            pair<const RegisterFile*, const Port*> registerPortPair =
                pair<const RegisterFile*, const Port*>(
                    sourceRegister, destPort);
            pair<registerPortSetIter, bool> registerPortResult = 
                registerPortConnections.insert(registerPortPair);
            if (registerPortResult.second) {
                ConnectionSet newSet;
                newSet.sourcePort = sourcePort;
                newSet.destPort = destPort;
                newSet.segment = segment;
                directConnections.push_back(newSet);
            }
        } else {
            ConnectionSet newSet;
            newSet.sourcePort = sourcePort;
            newSet.destPort = destPort;
            newSet.segment = segment;
            directConnections.push_back(newSet);
        }
    }
}

References allConnections, ProgrammabilityValidator::ConnectionSet::destPort, directConnections, TTAMachine::Port::parentUnit(), portRegisterConnections, registerPortConnections, registerRegisterConnections, ProgrammabilityValidator::ConnectionSet::segment, and ProgrammabilityValidator::ConnectionSet::sourcePort.

Referenced by findConnections().

Here is the call graph for this function:

addDirectConnectionsToProgram()

void ProgrammabilityValidator::addDirectConnectionsToProgram ( )

private

Adds all connections found in the machine to program.

Definition at line 1648 of file ProgrammabilityValidator.cc.

                                                        {
 
    // add all collected source - destination - segment sets to program
    for (unsigned int i = 0; i < directConnections.size(); i++) {
        ConnectionSet setToBeAdded = directConnections[i];
        addConnectionToProgram(setToBeAdded.sourcePort,
                               setToBeAdded.destPort,
                               setToBeAdded.segment,
                               directCounter);
    }
}

References addConnectionToProgram(), ProgrammabilityValidator::ConnectionSet::destPort, directConnections, directCounter, ProgrammabilityValidator::ConnectionSet::segment, and ProgrammabilityValidator::ConnectionSet::sourcePort.

Here is the call graph for this function:

addGlobalRegisterConnection()

void ProgrammabilityValidator::addGlobalRegisterConnection ( const Port *  sourcePort, const Port *  destPort, Segment *  segment  )

private

Adds global connection register connection to list of GCR connections. Moves can be genetated from these connections.

Parameters

sourcePort	Source port of the move.
destPort	Destionation port of the move.
segment	The segment of the move.

Definition at line 1280 of file ProgrammabilityValidator.cc.

                      {
 
    pair<const Port*, const Port*>  connectionPair = 
        pair<const Port*, const Port*>(sourcePort, destPort);
    pair<portSetIter, bool> result = gcrConnections.insert(connectionPair);
    // If the insertion was made the connection
    // can be added and it is unique.
    if (result.second) {
        
        // Find out if the source or destination unit is Register File.
        // Only one connection per port to RF and from RF to port is needed.
        const Unit* destUnit = destPort->parentUnit();
        const RegisterFile* destRegister =
            dynamic_cast<const RegisterFile*>(destUnit);
        const Unit* sourceUnit = sourcePort->parentUnit();
        const RegisterFile* sourceRegister =
            dynamic_cast<const RegisterFile*>(sourceUnit);
 
        if (destRegister != NULL) {
            if (sourceRegister != NULL) {
                pair<const RegisterFile*,
                    const RegisterFile*> registerRegisterPair =
                    pair<const RegisterFile*, const RegisterFile*>(
                        sourceRegister, destRegister);
                pair<registerRegisterSetIter, bool> registerRegisterResult = 
                    gcrRegisterConnections.insert(registerRegisterPair);
                if (registerRegisterResult.second) {
                    ConnectionSet newSet;
                    newSet.sourcePort = sourcePort;
                    newSet.destPort = destPort;
                    newSet.segment = segment;
                    globalRegisterConnections.push_back(newSet);
                }
            } else {
                // destination is a register but source is not
                pair<const Port*, const RegisterFile*> portRegisterPair =
                    pair<const Port*, const RegisterFile*>(
                        sourcePort, destRegister);
                pair<portRegisterSetIter, bool> portRegisterResult = 
                    portGcrConnections.insert(portRegisterPair);
                if (portRegisterResult.second) {
                    ConnectionSet newSet;
                    newSet.sourcePort = sourcePort;
                    newSet.destPort = destPort;
                    newSet.segment = segment;
                    globalRegisterConnections.push_back(newSet);
                }
            }
        } else if (sourceRegister != NULL) {
            pair<const RegisterFile*, const Port*> registerPortPair =
                pair<const RegisterFile*, const Port*>(
                    sourceRegister, destPort);
            pair<registerPortSetIter, bool> registerPortResult = 
                gcrPortConnections.insert(registerPortPair);
            if (registerPortResult.second) {
                ConnectionSet newSet;
                newSet.sourcePort = sourcePort;
                newSet.destPort = destPort;
                newSet.segment = segment;
                globalRegisterConnections.push_back(newSet);
            }
        } else {
            // source or destination should be register
            assert(false);
        }
    }
}

References assert, ProgrammabilityValidator::ConnectionSet::destPort, gcrConnections, gcrPortConnections, gcrRegisterConnections, globalRegisterConnections, TTAMachine::Port::parentUnit(), portGcrConnections, ProgrammabilityValidator::ConnectionSet::segment, and ProgrammabilityValidator::ConnectionSet::sourcePort.

Referenced by findGlobalRegisterConnections().

Here is the call graph for this function:

addGlobalRegisterConnectionsToProgram()

void ProgrammabilityValidator::addGlobalRegisterConnectionsToProgram ( )

private

Adds global connection registers connections to program.

Definition at line 1665 of file ProgrammabilityValidator.cc.

                                                                {
 
    // add all collected source - destination - segment sets to program
    for (unsigned int i = 0; i < globalRegisterConnections.size(); i++) {
        ConnectionSet setToBeAdded = globalRegisterConnections[i];
        addConnectionToProgram(setToBeAdded.sourcePort,
                               setToBeAdded.destPort,
                               setToBeAdded.segment,
                               gcrCounter);
    }
}

References addConnectionToProgram(), ProgrammabilityValidator::ConnectionSet::destPort, gcrCounter, globalRegisterConnections, ProgrammabilityValidator::ConnectionSet::segment, and ProgrammabilityValidator::ConnectionSet::sourcePort.

Referenced by findGlobalRegisterConnections().

Here is the call graph for this function:

addOperationConnections()

void ProgrammabilityValidator::addOperationConnections ( const FunctionUnit *  fu, set< HWOperation * > &  operations  )

private

Adds operations to connections.

Parameters

fu	The function unit that is the parentunit for the operations.
opertations	Set of FWOperations where new operations are added.

Definition at line 1237 of file ProgrammabilityValidator.cc.

                                   {
 
    for (int i = 0; i < fu->operationCount(); i++) {
        operations.insert(fu->operation(i));
    }
}

References TTAMachine::FunctionUnit::operation(), and TTAMachine::FunctionUnit::operationCount().

Referenced by findConnections().

Here is the call graph for this function:

checkBooleanRegister()

bool ProgrammabilityValidator::checkBooleanRegister

(

ProgrammabilityValidatorResults &

results

)

Check the machine for a boolean register file. Only one is allowed. Boolean register should have size and width of one.

Parameters

results

Results of the validation are added to the given instance.

Returns

Returns true if check is passed. False is returned if error is found.

Definition at line 361 of file ProgrammabilityValidator.cc.

                                              {
 
    bool returnValue = true;
    const Machine::RegisterFileNavigator& nav =
        machine_.registerFileNavigator();
    bool found = false;
    for (int i = 0; i < nav.count(); i++) {
        RegisterFile* rf = nav.item(i);
        if (rf->width() == 1) {
            if (!found) {
                found = true;
                booleanRegister_ = rf;
            } else {
                results.addError(BOOLEAN_REGISTER_ERROR,
                                 "Multiple boolean registers.");
                returnValue = false;
                break;
            }
        }
    }
 
    if (!found) {
        results.addError(BOOLEAN_REGISTER_ERROR,
                         "No boolean register found.");
        returnValue = false;
    }
    
    string buses = "";
    const Machine::BusNavigator& busNav =
    machine_.busNavigator();
    for (int i = 0; i < busNav.count(); i++) {
    Bus* bus = busNav.item(i);
        for (int n = 0; n < bus->guardCount(); n++) {
            RegisterGuard* registerGuard = 
                dynamic_cast<RegisterGuard*>(bus->guard(n));
            if (registerGuard != NULL) {
                if (registerGuard->parentBus() == bus && 
                    registerGuard->registerFile() == booleanRegister_ &&
                    registerGuard->registerIndex() == 0) {
                    continue;
                } else {
                    string message = 
                        "Missing boolean register guard on bus: ";
                    results.addError(BOOLEAN_REGISTER_GUARD_MISSING,
                                     message.append(bus->name()));
                    returnValue = false;
                    break;
                }
            }
        }
        if (bus->guardCount() == 0) {
            string message = 
                "Missing boolean register guard on bus: ";
            results.addError(BOOLEAN_REGISTER_GUARD_MISSING,
                             message.append(bus->name()));
            returnValue = false;
        }
    }
    return returnValue;
}

References ProgrammabilityValidatorResults::addError(), BOOLEAN_REGISTER_ERROR, BOOLEAN_REGISTER_GUARD_MISSING, booleanRegister_, TTAMachine::Machine::busNavigator(), TTAMachine::Machine::Navigator< ComponentType >::count(), TTAMachine::Bus::guard(), TTAMachine::Bus::guardCount(), TTAMachine::Machine::Navigator< ComponentType >::item(), machine_, TTAMachine::Component::name(), TTAMachine::Guard::parentBus(), TTAMachine::RegisterGuard::registerFile(), TTAMachine::Machine::registerFileNavigator(), TTAMachine::RegisterGuard::registerIndex(), and TTAMachine::BaseRegisterFile::width().

Referenced by main(), profile(), searchMissingRFConnections(), validate(), and validate().

Here is the call graph for this function:

checkPrimitiveSet()

void ProgrammabilityValidator::checkPrimitiveSet

(

ProgrammabilityValidatorResults &

results

)

const

Checks the machine which primitive operations are missing.

Parameters

results

Results of the validation are added to the given instance.

Definition at line 335 of file ProgrammabilityValidator.cc.

                                                    {
    
    std::vector<std::string> missingOps;
    minimalOpSetCheck_->missingOperations(machine_, missingOps);
 
    string msg = "Operation missing from the minimal operation set: ";
    std::vector<std::string>::iterator it = missingOps.begin();
    std::vector<std::string>::iterator end = missingOps.end();
    while (it != end) {
        results.addError(
                OPERATION_MISSING_FROM_THE_PRIMITIVE_OPERATION_SET,
                msg.append(*it++));
    }
}

References ProgrammabilityValidatorResults::addError(), machine_, minimalOpSetCheck_, MinimalOpSetCheck::missingOperations(), and OPERATION_MISSING_FROM_THE_PRIMITIVE_OPERATION_SET.

Referenced by profile(), validate(), and validate().

Here is the call graph for this function:

findConnections()

void ProgrammabilityValidator::findConnections

(

)

Finds out all the connections in the machine.

Parameters

printConnections

Flag for printing of connections.

Definition at line 1377 of file ProgrammabilityValidator.cc.

                                          {
 
    const Machine::FunctionUnitNavigator& fuNav =
    machine_.functionUnitNavigator();
    for (int i = 0; i < fuNav.count(); i++) {
    const FunctionUnit* fu = fuNav.item(i);
        map<const Socket*, Connections> fuConnections;
 
        // for every port we need to check which kind of socket 
        // the port is connected to 
    for (int j = 0; j < fu->portCount(); j++) {
        const Port* port = fu->port(j);
            const BaseFUPort* baseFUPort = 
                dynamic_cast<const BaseFUPort*>(port);
        const Socket* socket = port->inputSocket();
        
        // if not null, socket is an input socket
        if (socket != NULL) {
 
                Connections connections;
                set<Segment*> fuInputs;
                
                // connections to the input socket are listed to fuInputs
                listConnections(fuInputs, socket);                
                
                if (baseFUPort->isTriggering()) {
                    addConnections(fuInputs, connections.triggeredInputs);
                    addOperationConnections(fu, connections.operations);
                } else {
                    addConnections(fuInputs, connections.inputs);
                }
                fuConnections[socket] = connections;
                inputs.push_back(pair<const Port*, set<Segment*> >(
                                     port, fuInputs));
            }
        }
        FUConnections[fu->name()] = fuConnections;
    }
    const Machine::RegisterFileNavigator& rfNav =
    machine_.registerFileNavigator();
    for (int i = 0; i < rfNav.count(); i++) {
        
    const RegisterFile* rf = rfNav.item(i);
        map<const Socket*, Connections> rfConnections;
    
    for (int j = 0; j < rf->portCount(); j++) {
        const Port* port = rf->port(j);
        const Socket* socket = port->inputSocket();
        
        // if not null, socket is an input socket
        if (socket != NULL) {
 
                Connections connections;
        set<Segment*> rfInputs;
                listConnections(rfInputs, socket);
                addConnections(rfInputs, connections.inputs);
                connections.registers = rf->numberOfRegisters();
                rfConnections[socket] = connections;
                inputs.push_back(
            pair<const Port*,
                    set<Segment*> >(port, rfInputs));
        }
    }
    RFConnections[rf->name()] = rfConnections;
    
    }
    
    const ControlUnit* gcu = machine_.controlUnit();
    if (gcu != NULL) {
    map<const Socket*, Connections> gcuConnections;
    for (int j = 0; j < gcu->portCount(); j++) {
        const Port* port = gcu->port(j);
            const BaseFUPort* baseFUPort = 
                dynamic_cast<const BaseFUPort*>(port);
        const Socket* socket = port->inputSocket();
            
        // if not null, socket is an input socket
        if (socket != NULL) {
                Connections connections;
                set<Segment*> gcuInputs;
                listConnections(gcuInputs, socket);
                if (baseFUPort->isTriggering()) {
                    addConnections(gcuInputs, connections.triggeredInputs);
                    addOperationConnections(gcu, connections.operations);
                } else {
                    addConnections(gcuInputs, connections.inputs);
                }
                inputs.push_back(
                    pair<const Port*,
                    set<Segment*> >(port, gcuInputs));
                connections.registers = 0;
                gcuConnections[socket] = connections;
            }
        }
        GCUConnections[gcu->name()] = gcuConnections;
    }
    
    
    // now we look for output sockets
 
    for (int i = 0; i < fuNav.count(); i++) {
    const FunctionUnit* fu = fuNav.item(i);
    set<const Socket*> outputs;
    for (int j = 0; j < fu->portCount(); j++) {
        const Port* port = fu->port(j);
        const Socket* socket = port->outputSocket();
        
        // if not null, socket is an output socket
        if (socket != NULL) {
        
        set<Segment*> outputConnections;
        listConnections(outputConnections, socket);
        // go through every input
        for (unsigned int k = 0; k < inputs.size(); k++) {
            set<Segment*> intersection;
                    
                    // do an intersection between 
                    // inputs and socket connections
            SetTools::intersection(inputs[k].second,
                                             outputConnections,
                                             intersection);
 
                    // go through all the connections of 
                    // the intersection result
                    map<const Socket*, Connections> socketConnections = 
                        FUConnections[fu->name()];
                    Connections connections = socketConnections[socket];
 
                    set<Segment*>::iterator iter = 
                        intersection.begin();
                    for (; iter != intersection.end(); iter++) {
                        
                        if (!ContainerTools::containsValue(
                                connections.outputs,
                                *iter)) {
                            connections.outputs.insert(*iter);
                        }
                        addDirectConnection(port, inputs[k].first, *iter);
            }
                    socketConnections[socket] = connections;
                    FUConnections[fu->name()] = socketConnections;
        }
        }
    }
    }
    for (int i = 0; i < rfNav.count(); i++) {
    const TTAMachine::RegisterFile* rf = rfNav.item(i);
    set<const Socket*> outputs;
    for (int j = 0; j < rf->portCount(); j++) {
        const Port* port = rf->port(j);
        const Socket* socket = port->outputSocket();
 
        // if not null, socket is an output socket
        if (socket != NULL) {
        set<Segment*> outputConnections;
        listConnections(outputConnections, socket);
                
        for (unsigned int k = 0; k < inputs.size(); k++) {
            set<Segment*> intersection;
                    
                    
            SetTools::intersection(inputs[k].second,
                                             outputConnections,
                                             intersection);
                    map<const Socket*, Connections> socketConnections =
                        RFConnections[rf->name()];
                    Connections connections = socketConnections[socket];
 
                    set<Segment*>::iterator iter = 
                        intersection.begin();
                    for (; iter != intersection.end(); iter++) {
                        
                        if (!ContainerTools::containsValue(
                                connections.outputs,
                                *iter)) {
                            connections.outputs.insert(*iter);
                        }
                        addDirectConnection(port, inputs[k].first, *iter);
            }
                    socketConnections[socket] = connections;
                    RFConnections[rf->name()] = socketConnections;
                }
        }
    }
    }
    
    const Machine::ImmediateUnitNavigator& immNav =
    machine_.immediateUnitNavigator();
    for (int i = 0; i < immNav.count(); i++) {
    const TTAMachine::ImmediateUnit* imm = immNav.item(i);
    
    set<const Socket*> outputs;
    for (int j = 0; j < imm->portCount(); j++) {
        const Port* port = imm->port(j);
        const Socket* socket = port->outputSocket();
        
        // if not null, socket is an output socket
        if (socket != NULL) {
        set<Segment*> outputConnections;
        listConnections(outputConnections, socket);
        for (unsigned int k = 0; k < inputs.size(); k++) {
            set<Segment*> intersection;
            SetTools::intersection(inputs[k].second,
                                             outputConnections,
                                             intersection);
                    map<const Socket*, Connections> socketConnections =
                        IMMConnections[imm->name()];
                    Connections connections = socketConnections[socket];
 
                    set<Segment*>::iterator iter = 
                        intersection.begin();
                    for (; iter != intersection.end(); iter++) {
                        
                        if (!ContainerTools::containsValue(
                                connections.outputs,
                                *iter)) {
 
                            connections.outputs.insert(*iter);
                        }
                        addDirectConnection(port, inputs[k].first, *iter);
            }
                    connections.registers = imm->numberOfRegisters();
                    socketConnections[socket] = connections;
                    IMMConnections[imm->name()] = socketConnections;
        }
        }
    }
    }
    if (gcu != NULL) {
    set<const Socket*> outputs;
    for (int j = 0; j < gcu->portCount(); j++) {
        const Port* port = gcu->port(j);
        const Socket* socket = port->outputSocket();
        
        // if not null, socket is an output socket
        if (socket != NULL) {
        set<Segment*> outputConnections;
        listConnections(outputConnections, socket);
        for (unsigned int k = 0; k < inputs.size(); k++) {
            set<Segment*> intersection;
            SetTools::intersection(inputs[k].second,
                                             outputConnections,
                                             intersection);
                    map<const Socket*, Connections> socketConnections = 
                        GCUConnections[gcu->name()];
                    Connections connections = socketConnections[socket];
 
                    set<Segment*>::iterator iter = 
                        intersection.begin();
                    for (; iter != intersection.end(); iter++) {
 
                        if (!ContainerTools::containsValue(
                                connections.outputs,
                                *iter)) {
                            connections.outputs.insert(*iter);
                        }
                        addDirectConnection(port, inputs[k].first, *iter);
            }
                    socketConnections[socket] = connections;
                    GCUConnections[gcu->name()] = socketConnections;
        }
        }
    }
    }
}

References addConnections(), addDirectConnection(), addOperationConnections(), ContainerTools::containsValue(), TTAMachine::Machine::controlUnit(), TTAMachine::Machine::Navigator< ComponentType >::count(), FUConnections, TTAMachine::Machine::functionUnitNavigator(), GCUConnections, IMMConnections, TTAMachine::Machine::immediateUnitNavigator(), inputs, ProgrammabilityValidator::Connections::inputs, TTAMachine::Port::inputSocket(), SetTools::intersection(), TTAMachine::BaseFUPort::isTriggering(), TTAMachine::Machine::Navigator< ComponentType >::item(), listConnections(), machine_, TTAMachine::Component::name(), TTAMachine::BaseRegisterFile::numberOfRegisters(), ProgrammabilityValidator::Connections::operations, ProgrammabilityValidator::Connections::outputs, TTAMachine::Port::outputSocket(), TTAMachine::BaseRegisterFile::port(), TTAMachine::FunctionUnit::port(), TTAMachine::Unit::portCount(), TTAMachine::Machine::registerFileNavigator(), ProgrammabilityValidator::Connections::registers, RFConnections, and ProgrammabilityValidator::Connections::triggeredInputs.

Referenced by profile(), validate(), and validate().

Here is the call graph for this function:

findGlobalConnectionRegister()

const RegisterFile * ProgrammabilityValidator::findGlobalConnectionRegister

(

)

Finds the global connection register out of the machine.

The global connection register is register that has the best connecticity.

Returns

Pointer to the global connection register.

Definition at line 1789 of file ProgrammabilityValidator.cc.

                                                       {
 
    const RegisterFile* gcRegister = 0;
 
    int maxConnectivity = 0;
    int maxInputs = 0;
    int maxOutputs = 0;
    
    const Machine::RegisterFileNavigator& rfNav =
    machine_.registerFileNavigator();
    const Machine::BusNavigator& busNav =
    machine_.busNavigator();
 
    int maxWidth = 0;
 
    for (int i = 0; i < busNav.count(); i++) {
        Bus* bus = busNav.item(i);
        int width = bus->width();
 
        // find out the biggest bus width of the machine
        if (width > maxWidth) {
            maxWidth = width;
        }
    }
    
    for (int i = 0; i < rfNav.count(); i++) {
    const RegisterFile* rf = rfNav.item(i);
        
        if (rf->width() >= maxWidth) {
            map<const Socket*, Connections> rfConns = 
                RFConnections[rf->name()];
            set<Segment*> intersection;
            
            int inputs = 0;
            int outputs = 0;
            for (map<const Socket*,
                     Connections>::iterator n = rfConns.begin();
                 n != rfConns.end(); n++) {
                
                inputs += (*n).second.inputs.size();
                outputs += (*n).second.outputs.size();
            }
            int sum = inputs + outputs;
            int connectivity = 0;
            if (inputs > outputs) {
                connectivity = sum - (inputs - outputs);
            } else {
                connectivity = sum - (outputs - inputs);
                }
            if (connectivity > maxConnectivity) {
                gcRegister = rf;
                maxConnectivity = connectivity;
                maxInputs = inputs;
                maxOutputs = outputs;
            } else if (connectivity == maxConnectivity) {
                if (sum > (maxInputs + maxOutputs)) {
                    gcRegister = rf;
                    maxConnectivity = connectivity;
                    maxInputs = inputs;
                    maxOutputs = outputs;
                }
            }
        }
    }
    globalConnectionRegister_ = const_cast<RegisterFile*>(gcRegister);
    return gcRegister;
}

References TTAMachine::Machine::busNavigator(), TTAMachine::Machine::Navigator< ComponentType >::count(), globalConnectionRegister_, inputs, TTAMachine::Machine::Navigator< ComponentType >::item(), machine_, TTAMachine::Component::name(), TTAMachine::Machine::registerFileNavigator(), RFConnections, TTAMachine::BaseRegisterFile::width(), and TTAMachine::Bus::width().

Referenced by main(), profile(), validate(), and validate().

Here is the call graph for this function:

findGlobalRegisterConnections()

void ProgrammabilityValidator::findGlobalRegisterConnections

(

)

Finds out the connections to the register file and stores those in the procedure.

Definition at line 1252 of file ProgrammabilityValidator.cc.

                                                        {
    
    vector<ConnectionSet>::iterator connectionIter = directConnections.begin();
    for (; connectionIter != directConnections.end(); connectionIter++) {
        if ((*connectionIter).sourcePort->parentUnit() == 
            globalConnectionRegister_ ||
            (*connectionIter).destPort->parentUnit() == 
            globalConnectionRegister_) {
            
            addGlobalRegisterConnection(
                (*connectionIter).sourcePort,
                (*connectionIter).destPort,
                (*connectionIter).segment);
        }
    }
    addGlobalRegisterConnectionsToProgram();
}

References addGlobalRegisterConnection(), addGlobalRegisterConnectionsToProgram(), directConnections, and globalConnectionRegister_.

Referenced by profile(), and validate().

Here is the call graph for this function:

findRegisterGuard()

void ProgrammabilityValidator::findRegisterGuard ( Segment *  segment, RegisterGuard *&  guard  )

private

Finds the guard of the boolean register file.

Parameters

segment	The segment where the guard is searched from.
guard	The found guard is put here.

Definition at line 581 of file ProgrammabilityValidator.cc.

                                             {
    
    Bus* bus = segment->parentBus();
    for (int i = 0; i < bus->guardCount(); i++) {
        RegisterGuard* registerGuard = 
            dynamic_cast<RegisterGuard*>(bus->guard(i));
        if (registerGuard != NULL) {
            if (registerGuard->parentBus() == bus && 
                registerGuard->registerFile() == booleanRegister_ &&
                registerGuard->registerIndex() == 0) {
                guard = registerGuard;
            }
        }
    }
}

References booleanRegister_, TTAMachine::Bus::guard(), TTAMachine::Bus::guardCount(), TTAMachine::Guard::parentBus(), TTAMachine::Segment::parentBus(), TTAMachine::RegisterGuard::registerFile(), and TTAMachine::RegisterGuard::registerIndex().

Referenced by addConnectionToProgram().

Here is the call graph for this function:

listConnections()

void ProgrammabilityValidator::listConnections ( set< Segment * > &  connections, const Socket *  socket  )

private

Gererates a set of segments where the socket is connected.

Parameters

connections	Segments where the socket is connected is collected here.
socket	Socket which connections are searched.

Definition at line 797 of file ProgrammabilityValidator.cc.

                          {
    
    const Machine::BusNavigator& busNav =
    machine_.busNavigator();
    for (int i = 0; i < busNav.count(); i++) {
    Bus* bus = busNav.item(i);
    if (socket->isConnectedTo(*bus)) {
        for (int j = 0; j < bus->segmentCount(); j++) {
        Segment* segment = bus->segment(j);
        if (socket->isConnectedTo(*segment)) {
            // we have found the bus and the segment where
                    // the socket is connected
            connections.insert(segment);
        }
        }
    }
    }
}

References TTAMachine::Machine::busNavigator(), TTAMachine::Machine::Navigator< ComponentType >::count(), TTAMachine::Socket::isConnectedTo(), TTAMachine::Machine::Navigator< ComponentType >::item(), machine_, TTAMachine::Bus::segment(), and TTAMachine::Bus::segmentCount().

Referenced by findConnections().

Here is the call graph for this function:

printConnection()

void ProgrammabilityValidator::printConnection ( const Port *  sourcePort, const Port *  destPort, Segment *  segment, int &  counter  )

private

Prints one connection.

Parameters

sourcePort	The source port of the connection.
destPort	The destination port of the connection.
segment	The segment which is used in the connection.
counter	Updates the amount of printed connections.

Definition at line 433 of file ProgrammabilityValidator.cc.

                  {
 
    const Unit* sourceUnit = sourcePort->parentUnit();
    const Unit* destUnit = destPort->parentUnit();
    const BaseRegisterFile* destRF = 
        dynamic_cast<const BaseRegisterFile*>(destUnit);
    const BaseRegisterFile* sourceRF = 
        dynamic_cast<const BaseRegisterFile*>(sourceUnit);
    const FunctionUnit* destFU =
        dynamic_cast<const FunctionUnit*>(destUnit);
    const FunctionUnit* sourceFU = 
        dynamic_cast<const FunctionUnit*>(sourceUnit);
    const BaseFUPort* destBaseFUPort = 
        dynamic_cast<const BaseFUPort*>(destPort);
    const BaseFUPort* sourceBaseFUPort = 
        dynamic_cast<const BaseFUPort*>(sourcePort);
    
 
    if (sourceFU != 0) {
        // move is from FU or GCU
        if (sourceBaseFUPort->isTriggering()) {
            // move is from trigger port
            // this is not supported
            return;
        }
        // else
        // move is from FUPort
        
        if (destFU != 0) {
            // move is to FU or GCU
 
            if (destBaseFUPort->isTriggering()) {
                // move is to FU of CGU trigger port
                
                for (int n = 0; n < destFU->operationCount(); n++) {
 
                    HWOperation* destOperation = destFU->operation(n);
                    counter++;
                    std::cout << sourceUnit->name() << " : "
                  << sourcePort->outputSocket()->name()
                  << " -> "
                  << destPort->inputSocket()->name() << " ("
                              << destOperation->name()
                  << ")  ("
                  << segment->parentBus()->name() << ","
                  << segment->name() << ") " 
                  << std::endl;
                }
 
            }
            else {
                // move is to FUPort or Special register port
                // move is to FUPort
                counter++;
                std::cout << sourceUnit->name() << " : "
                          << sourcePort->outputSocket()->name()
                          << " -> "
                          << destPort->inputSocket()->name() << "  ("
                          << segment->parentBus()->name() << ","
                          << segment->name() << ") " 
                          << std::endl;
            }
            
        }
        else { //if (destRF != 0)
            // move is to RF
            for (int i = 0; i < destRF->numberOfRegisters(); i++) {
                counter++;
                std::cout << sourceUnit->name() << " : "
                          << sourcePort->outputSocket()->name()
                          << " -> "
                          << destPort->inputSocket()->name() << "("
                          << i
                          << ")  ("
                          << segment->parentBus()->name() << ","
                          << segment->name() << ") " 
                          << std::endl;
            }
        }
    }
    else if (sourceRF != 0) {
        // move is from RF or IMM
        for (int i = 0; i < sourceRF->numberOfRegisters(); i++) {
            if (destFU != 0) {
                // move is to FU or GCU
                if (destBaseFUPort->isTriggering()) {
                    // move is to FU of CGU trigger port
                    
                    for (int n = 0; n < destFU->operationCount(); n++) {
                        HWOperation* destOperation = destFU->operation(n);
                        counter++;
                        std::cout << sourceUnit->name() << " : "
                                  << sourcePort->outputSocket()->name() 
                                  << "("
                                  << i << ")"
                                  << " -> "
                                  << destPort->inputSocket()->name() << "("
                                  << destOperation->name()
                                  << ")  ("
                                  << segment->parentBus()->name() << ","
                                  << segment->name() << ") " 
                                  << std::endl;
                    }                
                }
                else {
                    // move is to FUPort or Special register port
                    counter++;
                    std::cout << sourceUnit->name() << " : "
                              << sourcePort->outputSocket()->name() << "("
                              << i << ")"
                              << " -> "
                              << destPort->inputSocket()->name() << "  ("
                              << segment->parentBus()->name() << ","
                              << segment->name() << ") " 
                              << std::endl;
                }
            }
            else { //if (destRF != 0)
                // move is to RF
                for (int j = 0; j < destRF->numberOfRegisters(); j++) {
                    counter++;
                    std::cout << sourceUnit->name() << " : "
                              << sourcePort->outputSocket()->name() << "("
                              << i << ")"
                              << " -> "
                              << destPort->inputSocket()->name() << "("
                              << j << ")  ("
                              << segment->parentBus()->name() << ","
                              << segment->name() << ") " 
                              << std::endl;
                }
            }
        }
    }
}

References TTAMachine::Port::inputSocket(), TTAMachine::BaseFUPort::isTriggering(), TTAMachine::HWOperation::name(), TTAMachine::Component::name(), TTAMachine::Segment::name(), TTAMachine::BaseRegisterFile::numberOfRegisters(), TTAMachine::FunctionUnit::operation(), TTAMachine::FunctionUnit::operationCount(), TTAMachine::Port::outputSocket(), TTAMachine::Segment::parentBus(), and TTAMachine::Port::parentUnit().

Referenced by printConnections(), and printRegisterConnections().

Here is the call graph for this function:

printConnections()

void ProgrammabilityValidator::printConnections

(

)

Prints all connections found in the machine.

Definition at line 1766 of file ProgrammabilityValidator.cc.

                                           {
 
    int counter = 0;
    for (unsigned int i = 0; i < directConnections.size(); i++) {
        ConnectionSet setToBePrinted = directConnections[i];
        printConnection(setToBePrinted.sourcePort,
                        setToBePrinted.destPort,
                        setToBePrinted.segment,
                        counter);
    }
    cout << "---------------------------" << endl;
    cout << "Total: " << counter << " connections" << endl;
}

References ProgrammabilityValidator::ConnectionSet::destPort, directConnections, printConnection(), ProgrammabilityValidator::ConnectionSet::segment, and ProgrammabilityValidator::ConnectionSet::sourcePort.

Referenced by main().

Here is the call graph for this function:

printNotConnectedSockets()

void ProgrammabilityValidator::printNotConnectedSockets

(

const RegisterFile *

rf

)

Prints the missing connections to the register file.

Parameters

rf	The register file which connections are handled.

Definition at line 1025 of file ProgrammabilityValidator.cc.

                                                                         {
 
    map<const Socket*, Connections> rfConnections =
        RFConnections[rf->name()];
 
    for (mapIter i = FUConnections.begin(); i != FUConnections.end(); i++) {
        for (map<const Socket*,
                 Connections>::iterator n = (*i).second.begin();
             n != (*i).second.end(); n++) {
 
            if ((*n).first->direction() == Socket::OUTPUT) {
 
                // one connection to register file is enough
                set<Segment*> outputIntersection;
                for (map<const Socket*,
                         Connections>::iterator m = rfConnections.begin();
                     m != rfConnections.end(); m++) {
 
                    if ((*m).first->direction() == Socket::INPUT) {
                        SetTools::intersection(
                            (*n).second.outputs,
                            (*m).second.inputs,
                            outputIntersection);
                    }
                }
                if (outputIntersection.size() == 0) {
                    cout << "Missing connection: " << (*i).first
                         << ": " << (*n).first->name()
                         << " -> " << rf->name() << ": " << endl;
                }
            } else if ((*n).first->direction() == Socket::INPUT) {
                set<Segment*> inputIntersection;
                for (map<const Socket*,
                         Connections>::iterator m = rfConnections.begin();
                     m != rfConnections.end(); m++) {
 
                    if ((*m).first->direction() == Socket::OUTPUT) {
                        SetTools::intersection(
                            (*n).second.inputs,
                            (*m).second.outputs,
                            inputIntersection);
                        SetTools::intersection(
                            (*n).second.triggeredInputs,
                            (*m).second.outputs,
                            inputIntersection);
                    }
                }
                if (inputIntersection.size() == 0) {
                    cout << "Missing connection: " << rf->name() 
                         << " -> " << (*i).first 
                         << ": " << (*n).first->name() << endl;
                }
            }
        }
    }
 
    for (mapIter i = GCUConnections.begin();
         i != GCUConnections.end(); i++) {
 
        for (map<const Socket*,
                 Connections>::iterator n = (*i).second.begin();
             n != (*i).second.end(); n++) {
 
            if ((*n).first->direction() == Socket::OUTPUT) {
 
                // one connection to register file is enough
                set<Segment*> outputIntersection;
                for (map<const Socket*,
                         Connections>::iterator m = rfConnections.begin();
                     m != rfConnections.end(); m++) {
 
                    if ((*m).first->direction() == Socket::INPUT) {
                        SetTools::intersection(
                            (*n).second.outputs,
                            (*m).second.inputs,
                            outputIntersection);
                    }
                }
                if (outputIntersection.size() == 0) {
                    cout << "Missing connection: " << (*i).first
                         << ": " << (*n).first->name()
                         << " -> " << rf->name() << endl;          
                }
            } else if ((*n).first->direction() == Socket::INPUT) {
                set<Segment*> inputIntersection;
                for (map<const Socket*,
                         Connections>::iterator m = rfConnections.begin();
                     m != rfConnections.end(); m++) {
 
                    if ((*m).first->direction() == Socket::OUTPUT) {
                        SetTools::intersection(
                            (*n).second.inputs,
                            (*m).second.outputs, 
                            inputIntersection);
                        SetTools::intersection(
                            (*n).second.triggeredInputs, 
                            (*m).second.outputs,
                            inputIntersection);
                    }
                }
                if (inputIntersection.size() == 0) {
                    cout << "Missing connection: " << rf->name()
                         << " -> " << (*i).first 
                         << ": " << (*n).first->name() << endl;
                }
            }
        }
    }
 
    for (mapIter i = IMMConnections.begin();
         i != IMMConnections.end(); i++) {
 
        set<Segment*> outputIntersection;
        set<Segment*> inputIntersection;
        for (map<const Socket*,
                 Connections>::iterator n = (*i).second.begin();
             n != (*i).second.end(); n++) {
 
            if ((*n).first->direction() == Socket::OUTPUT) {
                
                // one connection to register file is enough
                for (map<const Socket*,
                         Connections>::iterator m = rfConnections.begin();
                     m != rfConnections.end(); m++) {
 
                    if ((*m).first->direction() == Socket::INPUT) {
                        SetTools::intersection(
                            (*n).second.outputs,
                            (*m).second.inputs,
                            outputIntersection);
                    }
                }
            }
        }
        if (outputIntersection.size() == 0) {
            cout << "Missing connection: " << (*i).first 
                 << " -> " << rf->name() << endl;                
        }
    }
 
    for (mapIter i = RFConnections.begin(); i != RFConnections.end(); i++) {
        set<Segment*> outputIntersection;
        set<Segment*> inputIntersection;
        for (map<const Socket*,
                 Connections>::iterator n = (*i).second.begin();
             n != (*i).second.end(); n++) {
            
            if ((*n).first->direction() == Socket::OUTPUT) {
                
                // one connection to register file is enough
                for (map<const Socket*, 
                         Connections>::iterator m = rfConnections.begin();
                     m != rfConnections.end(); m++) {
 
                    if ((*m).first->direction() == Socket::INPUT) {
                        SetTools::intersection(
                            (*n).second.outputs,
                            (*m).second.inputs,
                            outputIntersection);
                    }
                }
            } else if ((*n).first->direction() == Socket::INPUT) {
                for (map<const Socket*,
                         Connections>::iterator m = rfConnections.begin();
                     m != rfConnections.end(); m++) {
 
                    if ((*m).first->direction() == Socket::OUTPUT) {
                        SetTools::intersection(
                            (*n).second.inputs,
                            (*m).second.outputs, 
                            inputIntersection);
                    }
                }
            }
        }
        if (outputIntersection.size() == 0) {
            cout << "Missing connection: " << (*i).first 
                 << " -> " << rf->name() << endl;                
        }
        if (inputIntersection.size() == 0) {
            cout << "Missing connection: " << rf->name() 
                 << " -> " << (*i).first << endl;
        }
    }
}

References FUConnections, GCUConnections, IMMConnections, TTAMachine::Socket::INPUT, SetTools::intersection(), TTAMachine::Component::name(), TTAMachine::Socket::OUTPUT, and RFConnections.

Here is the call graph for this function:

printRegisterConnections()

void ProgrammabilityValidator::printRegisterConnections

(

)

Prints connections from and to the global connection register.

Definition at line 1356 of file ProgrammabilityValidator.cc.

                                                   {
 
    int counter = 0;
    for (unsigned int i = 0; i < globalRegisterConnections.size(); i++) {
        ConnectionSet setToBePrinted = globalRegisterConnections[i];
        printConnection(setToBePrinted.sourcePort,
                        setToBePrinted.destPort,
                        setToBePrinted.segment,
                        counter);
    }
    cout << "----------------------------------------" << endl;
    cout << "Total:     " << counter << " connections" << endl;
}

References ProgrammabilityValidator::ConnectionSet::destPort, globalRegisterConnections, printConnection(), ProgrammabilityValidator::ConnectionSet::segment, and ProgrammabilityValidator::ConnectionSet::sourcePort.

Referenced by main().

Here is the call graph for this function:

profile()

TPEF::Binary * ProgrammabilityValidator::profile

(

ProgrammabilityValidatorResults &

results

)

Does all the steps needed to check maintaining the programmability.

Parameters

results

Possible error messages are added here.

Returns

Returns the binary.

Exceptions

NotAvailable	Thrown if binary creation is failed.
InvalidData	Thrown if the binary can't be created.

Definition at line 269 of file ProgrammabilityValidator.cc.

                                                                          {
    checkPrimitiveSet(results);
    
    if (!checkBooleanRegister(results)) {
        // error found in boolean register check.
        string msg = "Error found in boolean register check.";
        throw InvalidData(__FILE__, __LINE__, __func__, msg);
    }
 
    findConnections();
    findGlobalConnectionRegister();
    
    if (globalConnectionRegister_ == NULL) {
        results.addError(GLOBAL_CONNECTION_REGISTER_NOT_FOUND,
                         "Can't determine global connection register.");
        string msg = "Global connection register can't be determined.";
        throw InvalidData(__FILE__, __LINE__, __func__, msg);
    }
    
    findGlobalRegisterConnections();
 
    vector<pair<string, string> > missingInputs;
    vector<pair<string, string> > missingOutputs;
    searchMissingRFConnections(
        globalConnectionRegister_,
        missingInputs,
        missingOutputs);
 
 
    if ((missingInputs.size() > 0) || (missingOutputs.size() > 0)) {
        for (unsigned int i = 0; i < missingInputs.size(); i++) {
            string missing = "";
            missing.append("Missing connection: ");
            missing.append(missingInputs[i].first);
            missing.append(" : ");
            missing.append(missingInputs[i].second);
            missing.append(" -> ");
            missing.append(globalConnectionRegister_->name());
            results.addError(MISSING_CONNECTION, missing);
        }
        for (unsigned int i = 0; i < missingOutputs.size(); i++) {
            string missing = "";
            missing.append("Missing connection: ");
            missing.append(globalConnectionRegister_->name());
            missing.append(" -> ");
            missing.append(missingOutputs[i].first);
            missing.append(" : ");
            missing.append(missingOutputs[i].second);
            results.addError(MISSING_CONNECTION, missing);
        }
    }
    ProgramWriter progWriter(*program_);
    try {
        TPEF::Binary* binaryProgram = progWriter.createBinary();
        return binaryProgram;
    } catch (NotAvailable& e) {
        throw e;
    }
}

References __func__, ProgrammabilityValidatorResults::addError(), checkBooleanRegister(), checkPrimitiveSet(), TTAProgram::ProgramWriter::createBinary(), findConnections(), findGlobalConnectionRegister(), findGlobalRegisterConnections(), GLOBAL_CONNECTION_REGISTER_NOT_FOUND, globalConnectionRegister_, MISSING_CONNECTION, TTAMachine::Component::name(), program_, and searchMissingRFConnections().

Referenced by InstructionDictionary::compress(), and main().

Here is the call graph for this function:

searchMissingRFConnections()

void ProgrammabilityValidator::searchMissingRFConnections	(	const RegisterFile *	rf,
		vector< pair< string, string > > &	toConnections,
		vector< pair< string, string > > &	fromConnections
	)

Search and lists all the missing connections to the register file.

Parameters

rf	The register file which connections are handled.
toConnections	Missing inputs to the register file.
fromConnections	Missing outputs from the register file.

Definition at line 827 of file ProgrammabilityValidator.cc.

                                                    {
 
    if (booleanRegister_ == NULL) {
        ProgrammabilityValidatorResults results;
        checkBooleanRegister(results);
    }
 
    map<const Socket*, Connections> rfConnections = 
        RFConnections[rf->name()];
 
    for (mapIter i = FUConnections.begin(); i != FUConnections.end(); i++) {
        for (map<const Socket*,
                 Connections>::iterator n = (*i).second.begin();
             n != (*i).second.end(); n++) {
            if ((*n).first->direction() == Socket::OUTPUT) {
 
                // one connection to register file is enough
                set<Segment*> outputIntersection;
                for (map<const Socket*, 
                         Connections>::iterator m = rfConnections.begin();
                     m != rfConnections.end(); m++) {
                    if ((*m).first->direction() == Socket::INPUT) {
                        SetTools::intersection(
                            (*n).second.outputs, 
                            (*m).second.inputs,
                            outputIntersection);
                    }
                }
                if (outputIntersection.size() == 0) {
                    toConnections.push_back(
                        pair<string, string>(
                            (*i).first,
                            (*n).first->name()));
                }
            } else if ((*n).first->direction() == Socket::INPUT) {
                set<Segment*> inputIntersection;
                for (map<const Socket*,
                         Connections>::iterator m = rfConnections.begin();
                     m != rfConnections.end(); m++) {
                    if ((*m).first->direction() == Socket::OUTPUT) {
                        SetTools::intersection(
                            (*n).second.inputs,
                            (*m).second.outputs,
                            inputIntersection);
                        SetTools::intersection(
                            (*n).second.triggeredInputs, 
                            (*m).second.outputs,
                            inputIntersection);
                    }
                }
                if (inputIntersection.size() == 0) {
                    fromConnections.push_back(
                        pair<string, string>((*i).first,
                                             (*n).first->name()));
                }
            }
        }
    }
    
    for (mapIter i = GCUConnections.begin();
         i != GCUConnections.end(); i++) {
 
        for (map<const Socket*,
                 Connections>::iterator n = (*i).second.begin();
             n != (*i).second.end(); n++) {
            if ((*n).first->direction() == Socket::OUTPUT) {
 
                // one connection to register file is enough
                set<Segment*> outputIntersection;
                for (map<const Socket*,
                         Connections>::iterator m = rfConnections.begin();
                     m != rfConnections.end(); m++) {
                    if ((*m).first->direction() == Socket::INPUT) {
                        SetTools::intersection(
                            (*n).second.outputs,
                            (*m).second.inputs,
                            outputIntersection);
                    }
                }
                if (outputIntersection.size() == 0) {
                    toConnections.push_back(
                        pair<string, string>(
                            (*i).first, (*n).first->name()));
                }
            } else if ((*n).first->direction() == Socket::INPUT) {
                set<Segment*> inputIntersection;
                for (map<const Socket*,
                         Connections>::iterator m = rfConnections.begin();
                     m != rfConnections.end(); m++) {
                    if ((*m).first->direction() == Socket::OUTPUT) {
                        SetTools::intersection(
                            (*n).second.inputs,
                            (*m).second.outputs,
                            inputIntersection);
                        SetTools::intersection(
                            (*n).second.triggeredInputs,
                            (*m).second.outputs,
                            inputIntersection);
                    }
                }
                if (inputIntersection.size() == 0) {
                    fromConnections.push_back(
                        pair<string, string>(
                            (*i).first, (*n).first->name()));
                }
            }
        }
    }
 
    for (mapIter i = IMMConnections.begin();
         i != IMMConnections.end(); i++) {
 
        set<Segment*> outputIntersection;
        set<Segment*> inputIntersection;
        for (map<const Socket*,
                 Connections>::iterator n = (*i).second.begin();
             n != (*i).second.end(); n++) {
            if ((*n).first->direction() == Socket::OUTPUT) {
                
                // one connection to register file is enough
                for (map<const Socket*,
                         Connections>::iterator m = rfConnections.begin();
                     m != rfConnections.end(); m++) {
                    if ((*m).first->direction() == Socket::INPUT) {
                        SetTools::intersection(
                            (*n).second.outputs,
                            (*m).second.inputs,
                            outputIntersection);
                    }
                }
            }
        }
        if (outputIntersection.size() == 0) {
            toConnections.push_back(pair<string, string>((*i).first, "-"));
        }
    }
 
 
    for (mapIter i = RFConnections.begin(); i != RFConnections.end(); i++) {
        set<Segment*> outputIntersection;
        set<Segment*> inputIntersection;
        for (map<const Socket*,
                 Connections>::iterator n = (*i).second.begin();
             n != (*i).second.end(); n++) {
 
            if ((*n).first->direction() == Socket::OUTPUT) {
                
                // one connection to register file is enough
                for (map<const Socket*,
                         Connections>::iterator m = rfConnections.begin();
                     m != rfConnections.end(); m++) {
                    
                    if ((*m).first->direction() == Socket::INPUT) {
                        SetTools::intersection(
                            (*n).second.outputs,
                            (*m).second.inputs,
                            outputIntersection);
                    }
                }
            } else if ((*n).first->direction() == Socket::INPUT) {
                for (map<const Socket*,
                         Connections>::iterator m = rfConnections.begin();
                     m != rfConnections.end(); m++) {
 
                    if ((*m).first->direction() == Socket::OUTPUT) {
                        SetTools::intersection(
                            (*n).second.inputs,
                            (*m).second.outputs,
                            inputIntersection);
                    }
                }
            }
        }
        if (outputIntersection.size() == 0) {
            toConnections.push_back(pair<string, string>((*i).first, "-"));
        }
        if (inputIntersection.size() == 0) {
 
            // Connection to the boolean register file is not needed
            if (booleanRegister_ != NULL && 
                (*i).first != booleanRegister_->name()) {
                fromConnections.push_back(
                    pair<string, string>((*i).first, "-"));
            }
        }
    }
}

References booleanRegister_, checkBooleanRegister(), FUConnections, GCUConnections, IMMConnections, TTAMachine::Socket::INPUT, SetTools::intersection(), TTAMachine::Component::name(), TTAMachine::Socket::OUTPUT, and RFConnections.

Referenced by profile(), validate(), and validate().

Here is the call graph for this function:

validate() [1/2]

ProgrammabilityValidatorResults * ProgrammabilityValidator::validate

(

)

Does all validations of ProgrammabilityValidator.

Returns

Returns pointer to ProgrammabilityValidatorResults where all error messages are stored.

Definition at line 137 of file ProgrammabilityValidator.cc.

                                   {
 
    ProgrammabilityValidatorResults* results = 
        new ProgrammabilityValidatorResults();
 
    checkPrimitiveSet(*results);
    checkBooleanRegister(*results);
    findConnections();
    findGlobalConnectionRegister();
    
    if (globalConnectionRegister_ == NULL) {
        results->addError(GLOBAL_CONNECTION_REGISTER_NOT_FOUND,
                          "Can't determine global connection register.");
    }
    
    findGlobalRegisterConnections();
 
    vector<pair<string, string> > missingInputs;
    vector<pair<string, string> > missingOutputs;
    searchMissingRFConnections(
        globalConnectionRegister_,
        missingInputs,
        missingOutputs);
 
    if ((missingInputs.size() > 0) || (missingOutputs.size() > 0)) {
        for (unsigned int i = 0; i < missingInputs.size(); i++) {
            string missing = "";
            missing.append("Missing connection: ");
            missing.append(missingInputs[i].first);
            missing.append(" : ");
            missing.append(missingInputs[i].second);
            missing.append(" -> ");
            missing.append(globalConnectionRegister_->name());
            results->addError(MISSING_CONNECTION, missing);
        }
        for (unsigned int i = 0; i < missingOutputs.size(); i++) {
            string missing = "";
            missing.append("Missing connection: ");
            missing.append(globalConnectionRegister_->name());
            missing.append(" -> ");
            missing.append(missingOutputs[i].first);
            missing.append(" : ");
            missing.append(missingOutputs[i].second);
            results->addError(MISSING_CONNECTION, missing);
        }
    }
    return results;
}

References ProgrammabilityValidatorResults::addError(), checkBooleanRegister(), checkPrimitiveSet(), findConnections(), findGlobalConnectionRegister(), findGlobalRegisterConnections(), GLOBAL_CONNECTION_REGISTER_NOT_FOUND, globalConnectionRegister_, MISSING_CONNECTION, TTAMachine::Component::name(), and searchMissingRFConnections().

Referenced by ValidateMachineDialog::onValidate().

Here is the call graph for this function:

validate() [2/2]

ProgrammabilityValidatorResults * ProgrammabilityValidator::validate

(

const std::set< ErrorCode > &

errorsToCheck

)

Does selected validations of ProgrammabilityValidator.

Parameters

errorsToCheck

Contains the error codes for the errors to check.

Returns

Returns pointer to ProgrammabilityValidatorResults where all error messages are stored.

Definition at line 195 of file ProgrammabilityValidator.cc.

                                                                         {
 
    ProgrammabilityValidatorResults* results = 
        new ProgrammabilityValidatorResults();
 
    for (std::set<ErrorCode>::const_iterator iter = errorsToCheck.begin();
         iter != errorsToCheck.end(); iter++) {
        ErrorCode code = *iter;
        if (code == OPERATION_MISSING_FROM_THE_PRIMITIVE_OPERATION_SET) {
            checkPrimitiveSet(*results);
        } else if (code == BOOLEAN_REGISTER_ERROR ||
                   code == BOOLEAN_REGISTER_GUARD_MISSING) {
            checkBooleanRegister(*results);
        } else if (code == GLOBAL_CONNECTION_REGISTER_NOT_FOUND) {
            findConnections();
            findGlobalConnectionRegister();
            if (globalConnectionRegister_ == NULL) {
                results->addError(GLOBAL_CONNECTION_REGISTER_NOT_FOUND,
                                 "Can't determine global connection register.");
            }
        } else if (code == MISSING_CONNECTION) {
            findConnections();
            findGlobalConnectionRegister();
            if (globalConnectionRegister_ == NULL) {
                results->addError(GLOBAL_CONNECTION_REGISTER_NOT_FOUND,
                                  "Can't determine global connection register.");
                break;
            }
            vector<pair<string, string> > missingInputs;
            vector<pair<string, string> > missingOutputs;
            searchMissingRFConnections(
                globalConnectionRegister_,
                missingInputs,
                missingOutputs);
 
            if ((missingInputs.size() > 0) || (missingOutputs.size() > 0)) {
                for (unsigned int i = 0; i < missingInputs.size(); i++) {
                    string missing = "";
                    missing.append("Missing connection: ");
                    missing.append(missingInputs[i].first);
                    missing.append(" : ");
                    missing.append(missingInputs[i].second);
                    missing.append(" -> ");
                    missing.append(globalConnectionRegister_->name());
                    results->addError(MISSING_CONNECTION, missing);
                }
                for (unsigned int i = 0; i < missingOutputs.size(); i++) {
                    string missing = "";
                    missing.append("Missing connection: ");
                    missing.append(globalConnectionRegister_->name());
                    missing.append(" -> ");
                    missing.append(missingOutputs[i].first);
                    missing.append(" : ");
                    missing.append(missingOutputs[i].second);
                    results->addError(MISSING_CONNECTION, missing);
                }
            }
        } else {
            assert(false);
        }
    }
    return results;
}

References ProgrammabilityValidatorResults::addError(), assert, BOOLEAN_REGISTER_ERROR, BOOLEAN_REGISTER_GUARD_MISSING, checkBooleanRegister(), checkPrimitiveSet(), findConnections(), findGlobalConnectionRegister(), GLOBAL_CONNECTION_REGISTER_NOT_FOUND, globalConnectionRegister_, MISSING_CONNECTION, TTAMachine::Component::name(), OPERATION_MISSING_FROM_THE_PRIMITIVE_OPERATION_SET, and searchMissingRFConnections().

Here is the call graph for this function:

Member Data Documentation

allConnections

set<pair<const Port*, const Port*> > ProgrammabilityValidator::allConnections

private

Set of connections to ensure that same Move is not done in multiple buses.

Definition at line 193 of file ProgrammabilityValidator.hh.

Referenced by addDirectConnection().

booleanRegister_

RegisterFile* ProgrammabilityValidator::booleanRegister_

private

Boolean register file of the machine.

Definition at line 161 of file ProgrammabilityValidator.hh.

Referenced by checkBooleanRegister(), findRegisterGuard(), ProgrammabilityValidator(), and searchMissingRFConnections().

directConnections

vector<ConnectionSet> ProgrammabilityValidator::directConnections

private

Storage of all the Moves that are found in the machine.

Definition at line 207 of file ProgrammabilityValidator.hh.

Referenced by addDirectConnection(), addDirectConnectionsToProgram(), findGlobalRegisterConnections(), and printConnections().

directCounter

int ProgrammabilityValidator::directCounter

private

The counter of direct connections added to the program.

Definition at line 187 of file ProgrammabilityValidator.hh.

Referenced by addDirectConnectionsToProgram(), and ProgrammabilityValidator().

FUConnections

map<string, map<const Socket*, Connections> > ProgrammabilityValidator::FUConnections

private

Function unit connections.

Definition at line 212 of file ProgrammabilityValidator.hh.

Referenced by findConnections(), printNotConnectedSockets(), ProgrammabilityValidator(), searchMissingRFConnections(), and ~ProgrammabilityValidator().

gcrConnections

set<pair<const Port*, const Port*> > ProgrammabilityValidator::gcrConnections

private

Definition at line 194 of file ProgrammabilityValidator.hh.

Referenced by addGlobalRegisterConnection().

gcrCounter

int ProgrammabilityValidator::gcrCounter

private

The counter of global register file connections added to the program.

Definition at line 189 of file ProgrammabilityValidator.hh.

Referenced by addGlobalRegisterConnectionsToProgram(), and ProgrammabilityValidator().

gcrPortConnections

set<pair<const RegisterFile*, const Port*> > ProgrammabilityValidator::gcrPortConnections

private

Definition at line 203 of file ProgrammabilityValidator.hh.

Referenced by addGlobalRegisterConnection().

gcrRegisterConnections

set<pair<const RegisterFile*, const RegisterFile*> > ProgrammabilityValidator::gcrRegisterConnections

private

Definition at line 204 of file ProgrammabilityValidator.hh.

Referenced by addGlobalRegisterConnection().

GCUConnections

map<string, map<const Socket*, Connections> > ProgrammabilityValidator::GCUConnections

private

Global control unit connections.

Definition at line 214 of file ProgrammabilityValidator.hh.

Referenced by findConnections(), printNotConnectedSockets(), ProgrammabilityValidator(), searchMissingRFConnections(), and ~ProgrammabilityValidator().

globalConnectionRegister_

RegisterFile* ProgrammabilityValidator::globalConnectionRegister_

private

The global connection register of the machine.

Definition at line 163 of file ProgrammabilityValidator.hh.

Referenced by findGlobalConnectionRegister(), findGlobalRegisterConnections(), profile(), validate(), and validate().

globalRegisterConnections

vector<ConnectionSet> ProgrammabilityValidator::globalRegisterConnections

private

Storage of all Moves to and from the Global Connection Register.

Definition at line 209 of file ProgrammabilityValidator.hh.

Referenced by addGlobalRegisterConnection(), addGlobalRegisterConnectionsToProgram(), and printRegisterConnections().

IMMConnections

map<string, map<const Socket*, Connections> > ProgrammabilityValidator::IMMConnections

private

Immediate unit connections.

Definition at line 218 of file ProgrammabilityValidator.hh.

Referenced by findConnections(), printNotConnectedSockets(), ProgrammabilityValidator(), searchMissingRFConnections(), and ~ProgrammabilityValidator().

inputs

vector<pair<const Port*, set<Segment*> > > ProgrammabilityValidator::inputs

private

All inputs found in the machine are stored here.

Definition at line 168 of file ProgrammabilityValidator.hh.

Referenced by findConnections(), and findGlobalConnectionRegister().

machine_

const Machine& ProgrammabilityValidator::machine_

private

the target machine

Definition at line 155 of file ProgrammabilityValidator.hh.

Referenced by checkBooleanRegister(), checkPrimitiveSet(), findConnections(), findGlobalConnectionRegister(), listConnections(), and ProgrammabilityValidator().

minimalOpSetCheck_

MinimalOpSetCheck* ProgrammabilityValidator::minimalOpSetCheck_

private

Minimal operation checker.

Definition at line 165 of file ProgrammabilityValidator.hh.

Referenced by checkPrimitiveSet(), and ~ProgrammabilityValidator().

portGcrConnections

set<pair<const Port*, const RegisterFile*> > ProgrammabilityValidator::portGcrConnections

private

Definition at line 202 of file ProgrammabilityValidator.hh.

Referenced by addGlobalRegisterConnection().

portRegisterConnections

set<pair<const Port*, const RegisterFile*> > ProgrammabilityValidator::portRegisterConnections

private

Set of unit connections to ensure that only one connection per register file is added.

Definition at line 198 of file ProgrammabilityValidator.hh.

Referenced by addDirectConnection().

procedure_

Procedure* ProgrammabilityValidator::procedure_

private

Procedure of the program.

Definition at line 159 of file ProgrammabilityValidator.hh.

Referenced by addConnectionToProgram(), and ProgrammabilityValidator().

program_

Program* ProgrammabilityValidator::program_

private

Program where moves are generated.

Definition at line 157 of file ProgrammabilityValidator.hh.

Referenced by profile(), and ProgrammabilityValidator().

registerPortConnections

set<pair<const RegisterFile*, const Port*> > ProgrammabilityValidator::registerPortConnections

private

Definition at line 199 of file ProgrammabilityValidator.hh.

Referenced by addDirectConnection().

registerRegisterConnections

set<pair<const RegisterFile*, const RegisterFile*> > ProgrammabilityValidator::registerRegisterConnections

private

Definition at line 200 of file ProgrammabilityValidator.hh.

Referenced by addDirectConnection().

RFConnections

map<string, map<const Socket*, Connections> > ProgrammabilityValidator::RFConnections

private

Register file connections.

Definition at line 216 of file ProgrammabilityValidator.hh.

Referenced by findConnections(), findGlobalConnectionRegister(), printNotConnectedSockets(), ProgrammabilityValidator(), searchMissingRFConnections(), and ~ProgrammabilityValidator().

---

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

• ProgrammabilityValidator.hh
• ProgrammabilityValidator.cc