#include <MachineValidator.hh>

Collaboration diagram for MachineValidator:

Public Types
enum	ErrorCode { GCU_MISSING, GCU_AS_MISSING, USED_IO_NOT_BOUND, DIFFERENT_PORT_FOR_JUMP_AND_CALL, PC_PORT_MISSING, RA_PORT_MISSING, PC_AND_RA_PORTS_HAVE_UNEQUAL_WIDTH, IMEM_ADDR_WIDTH_DIFFERS_FROM_RA_AND_PC, FU_NO_VALID_OPERATIONS, FU_PORT_MISSING }
	Error codes for different errors. More...

Public Member Functions
	MachineValidator (const TTAMachine::Machine &machine)

virtual	~MachineValidator ()

MachineValidatorResults *	validate (const std::set< ErrorCode > &errorsToCheck) const

Private Member Functions
void	checkGCUExists (MachineValidatorResults &results) const

void	checkGCUHasAddressSpace (MachineValidatorResults &results) const

void	checkOperandBindings (MachineValidatorResults &results) const

void	checkJumpAndCallOperandBindings (MachineValidatorResults &results) const

void	checkProgramCounterPort (MachineValidatorResults &results) const

void	checkReturnAddressPort (MachineValidatorResults &results) const

void	checkRAPortHasSameWidthAsPCPort (MachineValidatorResults &results) const

void	checkIMemAddrWidth (MachineValidatorResults &results) const

void	checkFUConnections (MachineValidatorResults &results) const

Private Attributes
const TTAMachine::Machine &	machine_
	The machine to validate. More...

Detailed Description

Validator of target architecture definitions (machines). It tests a given machine against various criteria (completeness, implementation-dependent restrictions to structure, synthesisability).

Definition at line 52 of file MachineValidator.hh.

Member Enumeration Documentation

◆ ErrorCode

enum MachineValidator::ErrorCode

Error codes for different errors.

Enumerator
GCU_MISSING	GCU missing in machine.
GCU_AS_MISSING	Address space missing in GCU.
USED_IO_NOT_BOUND	Pipeline uses an IO which is not bound.
DIFFERENT_PORT_FOR_JUMP_AND_CALL	JUMP and CALL uses different port in GCU.
PC_PORT_MISSING	PC port missing in GCU.
RA_PORT_MISSING	RA port missing in GCU.
PC_AND_RA_PORTS_HAVE_UNEQUAL_WIDTH	RA and PC ports have unequal width.
IMEM_ADDR_WIDTH_DIFFERS_FROM_RA_AND_PC	Instruction memory address width differs from PC/RA port width.
FU_NO_VALID_OPERATIONS	FU has no operations with a trigger.
FU_PORT_MISSING	FU is missing ports.

Definition at line 55 of file MachineValidator.hh.

                    {
         /// GCU missing in machine.
         GCU_MISSING,
         /// Address space missing in GCU.
         GCU_AS_MISSING,
         /// Pipeline uses an IO which is not bound.
         USED_IO_NOT_BOUND,
         /// JUMP and CALL uses different port in GCU.
         DIFFERENT_PORT_FOR_JUMP_AND_CALL,
         /// PC port missing in GCU.
         PC_PORT_MISSING,
         /// RA port missing in GCU.
         RA_PORT_MISSING,
         /// RA and PC ports have unequal width.
         PC_AND_RA_PORTS_HAVE_UNEQUAL_WIDTH,
         /// Instruction memory address width differs from PC/RA port width.
         IMEM_ADDR_WIDTH_DIFFERS_FROM_RA_AND_PC,
         /// FU has no operations with a trigger
         FU_NO_VALID_OPERATIONS,
         /// FU is missing ports
         FU_PORT_MISSING
     };

Constructor & Destructor Documentation

◆ MachineValidator()

MachineValidator::MachineValidator ( const TTAMachine::Machine & machine )

The constructor.

Parameters

machine The machine to validate.

Definition at line 62 of file MachineValidator.cc.

                                                                    :
     machine_(machine) {
 }

◆ ~MachineValidator()

MachineValidator::~MachineValidator ( )

virtual

The destructor.

Definition at line 70 of file MachineValidator.cc.

70 {

71 }

Member Function Documentation

◆ checkFUConnections()

void MachineValidator::checkFUConnections ( MachineValidatorResults & results ) const

private

Checks that the every FU has all the input and output ports that it needs.

Parameters

results Results of the validation are added to the given instance.

Definition at line 362 of file MachineValidator.cc.

                                                                            {
     const Machine::FunctionUnitNavigator fuNav =
         machine_.functionUnitNavigator();
  
     for (int i = 0; i < fuNav.count(); i++) {
         FunctionUnit& fu = *fuNav.item(i);
         for (int p = 0; p < fu.operationPortCount(); p++) {
             FUPort& port = *fu.operationPort(p);
             if (port.socketCount() == 0) {
                 string errorMsg = "The machine has an FU with missing ports.";
                 results.addError(FU_PORT_MISSING, errorMsg);
             }
         }
     }
 }

References MachineValidatorResults::addError(), TTAMachine::Machine::Navigator< ComponentType >::count(), FU_PORT_MISSING, TTAMachine::Machine::functionUnitNavigator(), TTAMachine::Machine::Navigator< ComponentType >::item(), machine_, TTAMachine::FunctionUnit::operationPort(), TTAMachine::FunctionUnit::operationPortCount(), and TTAMachine::Port::socketCount().

Referenced by validate().

Here is the call graph for this function:

◆ checkGCUExists()

void MachineValidator::checkGCUExists ( MachineValidatorResults & results ) const

private

Checks that the machine has a control unit.

Parameters

results Results of the validation are added to the given instance.

Definition at line 120 of file MachineValidator.cc.

                                                                        {
     if (machine_.controlUnit() == NULL) {
         string errorMsg = "The machine does not have a GCU.";
         results.addError(GCU_MISSING, errorMsg);
     }
 }

References MachineValidatorResults::addError(), TTAMachine::Machine::controlUnit(), GCU_MISSING, and machine_.

Referenced by validate().

Here is the call graph for this function:

◆ checkGCUHasAddressSpace()

void MachineValidator::checkGCUHasAddressSpace ( MachineValidatorResults & results ) const

private

Checks that the GCU has an address space.

Parameters

results Results of the validation are added to the given instance.

Definition at line 134 of file MachineValidator.cc.

                                             {
  
     ControlUnit* gcu = machine_.controlUnit();
     if (gcu == NULL) {
         return;
     }
     if (gcu->addressSpace() == NULL) {
         string errorMsg = "The GCU does not have an address space.";
         results.addError(GCU_AS_MISSING, errorMsg);
     }
 }

References MachineValidatorResults::addError(), TTAMachine::FunctionUnit::addressSpace(), TTAMachine::Machine::controlUnit(), GCU_AS_MISSING, and machine_.

Referenced by validate().

Here is the call graph for this function:

◆ checkIMemAddrWidth()

void MachineValidator::checkIMemAddrWidth ( MachineValidatorResults & results ) const

private

Checks that the address width of instruction memory is the same as PC and RA port width.

Parameters

results Results of the validation are added to the given instance.

Definition at line 309 of file MachineValidator.cc.

                                             {
  
     ControlUnit* gcu = machine_.controlUnit();
     if (gcu == NULL) {
         return;
     }
  
     AddressSpace* imem = gcu->addressSpace();
     if (imem == NULL) {
         return;
     }
  
     int addrWidth = MathTools::requiredBits(imem->end());
  
     if (gcu->hasReturnAddressPort()) {
         SpecialRegisterPort* raPort = gcu->returnAddressPort();
         if (raPort->width() != addrWidth) {
             string errorMsg =
                 "Return address port has different width than "
                 "instruction memory address.";
             results.addError(
                 IMEM_ADDR_WIDTH_DIFFERS_FROM_RA_AND_PC, errorMsg);
         }
     } else {
         FUPort* pcPort = NULL;
         if (gcu->hasOperation(JUMP)) {
             HWOperation* jumpOp = gcu->operation(JUMP);
             pcPort = jumpOp->port(1);
         }
         if (pcPort == NULL && gcu->hasOperation(CALL)) {
             HWOperation* callOp = gcu->operation(CALL);
             pcPort = callOp->port(1);
         }
  
         if (pcPort != NULL && pcPort->width() != addrWidth) {
             string errorMsg =
                 "Program counter port has different width than instruction "
                 "memory address.";
             results.addError(
                 IMEM_ADDR_WIDTH_DIFFERS_FROM_RA_AND_PC, errorMsg);
         }
     }
 }

References MachineValidatorResults::addError(), TTAMachine::FunctionUnit::addressSpace(), CALL, TTAMachine::Machine::controlUnit(), TTAMachine::AddressSpace::end(), TTAMachine::FunctionUnit::hasOperation(), TTAMachine::ControlUnit::hasReturnAddressPort(), IMEM_ADDR_WIDTH_DIFFERS_FROM_RA_AND_PC, JUMP, machine_, TTAMachine::FunctionUnit::operation(), TTAMachine::HWOperation::port(), MathTools::requiredBits(), TTAMachine::ControlUnit::returnAddressPort(), and TTAMachine::BaseFUPort::width().

Referenced by validate().

Here is the call graph for this function:

◆ checkJumpAndCallOperandBindings()

void MachineValidator::checkJumpAndCallOperandBindings ( MachineValidatorResults & results ) const

private

Checks that the operands of JUMP and CALL operations are bound to the same port in GCU.

Parameters

results Results of the validation are added to the given instance.

Definition at line 179 of file MachineValidator.cc.

                                             {
  
     ControlUnit* gcu = machine_.controlUnit();
     if (gcu == NULL) {
         return;
     }
  
     if (gcu->hasOperation(CALL) && gcu->hasOperation(JUMP)) {
         HWOperation* callOp = gcu->operation(CALL);
         HWOperation* jumpOp = gcu->operation(JUMP);
         FUPort* pcPort1 = callOp->port(1);
         FUPort* pcPort2 = jumpOp->port(1);
  
         if (pcPort1 != NULL && pcPort2 != NULL && pcPort1 != pcPort2) {
             string errorMsg =
                 "Operands of JUMP and CALL operations are not bound to the "
                 "same port in GCU.";
             results.addError(DIFFERENT_PORT_FOR_JUMP_AND_CALL, errorMsg);
         }
     }
 }

References MachineValidatorResults::addError(), CALL, TTAMachine::Machine::controlUnit(), DIFFERENT_PORT_FOR_JUMP_AND_CALL, TTAMachine::FunctionUnit::hasOperation(), JUMP, machine_, TTAMachine::FunctionUnit::operation(), and TTAMachine::HWOperation::port().

Referenced by validate().

Here is the call graph for this function:

◆ checkOperandBindings()

void MachineValidator::checkOperandBindings ( MachineValidatorResults & results ) const

private

Checks that all the used operands of operations are bound to some port in function units.

Parameters

results Results of the validation are added to the given instance.

Definition at line 155 of file MachineValidator.cc.

                                             {
  
     Machine::FunctionUnitNavigator fuNav = machine_.functionUnitNavigator();
     for (int i = 0; i < fuNav.count(); i++) {
         FunctionUnit* fu = fuNav.item(i);
         FUValidator::checkOperandBindings(*fu, results);
     }
  
     // check GCU too
     ControlUnit* gcu = machine_.controlUnit();
     if (gcu != NULL) {
         FUValidator::checkOperandBindings(*gcu, results);
     }
 }

References FUValidator::checkOperandBindings(), TTAMachine::Machine::controlUnit(), TTAMachine::Machine::Navigator< ComponentType >::count(), TTAMachine::Machine::functionUnitNavigator(), TTAMachine::Machine::Navigator< ComponentType >::item(), and machine_.

Referenced by validate().

Here is the call graph for this function:

◆ checkProgramCounterPort()

void MachineValidator::checkProgramCounterPort ( MachineValidatorResults & results ) const

private

Checks that the GCU has a PC port if it has JUMP or CALL operation.

Parameters

results Results of the validation are added to the given instance.

Definition at line 209 of file MachineValidator.cc.

                                             {
  
     ControlUnit* gcu = machine_.controlUnit();
     if (gcu == NULL) {
         return;
     }
  
     if (gcu->hasOperation(CALL)) {
         HWOperation* callOp = gcu->operation(CALL);
         FUPort* pcPort = callOp->port(1);
         if (pcPort == NULL) {
             string errorMsg =
                 "Operand 1 of CALL operation is not bound to any port.";
             results.addError(PC_PORT_MISSING, errorMsg);
         }
     }
  
     if (gcu->hasOperation(JUMP)) {
         HWOperation* jumpOp = gcu->operation(JUMP);
         FUPort* pcPort = jumpOp->port(1);
         if (pcPort == NULL) {
             string errorMsg =
                 "Operand 1 of JUMP operation is not bound to any port.";
             results.addError(PC_PORT_MISSING, errorMsg);
         }
     }
 }

References MachineValidatorResults::addError(), CALL, TTAMachine::Machine::controlUnit(), TTAMachine::FunctionUnit::hasOperation(), JUMP, machine_, TTAMachine::FunctionUnit::operation(), PC_PORT_MISSING, and TTAMachine::HWOperation::port().

Referenced by validate().

Here is the call graph for this function:

◆ checkRAPortHasSameWidthAsPCPort()

void MachineValidator::checkRAPortHasSameWidthAsPCPort ( MachineValidatorResults & results ) const

private

Checks that the return address port has the same width as program counter port if both exists.

Parameters

results Results of the validation are added to the given instance.

Definition at line 271 of file MachineValidator.cc.

                                             {
  
     ControlUnit* gcu = machine_.controlUnit();
     if (gcu == NULL) {
         return;
     }
     if (!gcu->hasReturnAddressPort()) {
         return;
     }
  
     SpecialRegisterPort* raPort = gcu->returnAddressPort();
     if (gcu->hasOperation(CALL)) {
         FUPort* pcPort = gcu->operation(CALL)->port(1);
         if (pcPort != NULL && pcPort->width() != raPort->width()) {
             string errorMsg = "PC and RA ports have unequal width.";
             results.addError(PC_AND_RA_PORTS_HAVE_UNEQUAL_WIDTH, errorMsg);
             return;
         }
     }
     if (gcu->hasOperation(JUMP)) {
         FUPort* pcPort = gcu->operation(JUMP)->port(1);
         if (pcPort != NULL && pcPort->width() != raPort->width()) {
             string errorMsg = "PC and RA ports have unequal width.";
             results.addError(PC_AND_RA_PORTS_HAVE_UNEQUAL_WIDTH, errorMsg);
             return;
         }
     }
 }

References MachineValidatorResults::addError(), CALL, TTAMachine::Machine::controlUnit(), TTAMachine::FunctionUnit::hasOperation(), TTAMachine::ControlUnit::hasReturnAddressPort(), JUMP, machine_, TTAMachine::FunctionUnit::operation(), PC_AND_RA_PORTS_HAVE_UNEQUAL_WIDTH, TTAMachine::HWOperation::port(), TTAMachine::ControlUnit::returnAddressPort(), and TTAMachine::BaseFUPort::width().

Referenced by validate().

Here is the call graph for this function:

◆ checkReturnAddressPort()

void MachineValidator::checkReturnAddressPort ( MachineValidatorResults & results ) const

private

Checks that the GCU has return address port if it has CALL operation.

Parameters

results Results of the validation are added to the given instance.

Definition at line 245 of file MachineValidator.cc.

                                             {
  
     ControlUnit* gcu = machine_.controlUnit();
     if (gcu == NULL) {
         return;
     }
  
     if (gcu->hasOperation(CALL)) {
         if (!gcu->hasReturnAddressPort()) {
             string errorMsg =
                 "GCU does not have return address port which is needed by "
                 "CALL operation.";
             results.addError(RA_PORT_MISSING, errorMsg);
         }
     }
 }

References MachineValidatorResults::addError(), CALL, TTAMachine::Machine::controlUnit(), TTAMachine::FunctionUnit::hasOperation(), TTAMachine::ControlUnit::hasReturnAddressPort(), machine_, and RA_PORT_MISSING.

Referenced by validate().

Here is the call graph for this function:

◆ validate()

MachineValidatorResults * MachineValidator::validate ( const std::set< ErrorCode > & errorsToCheck ) const

Validates the machine.

Parameters

errorsToCheck Contains the error codes for the errors to check.

Returns: Results of the validation.

Definition at line 81 of file MachineValidator.cc.

                                                                        {
  
     MachineValidatorResults* results = new MachineValidatorResults();
     for (std::set<ErrorCode>::const_iterator iter = errorsToCheck.begin();
          iter != errorsToCheck.end(); iter++) {
         ErrorCode code = *iter;
         if (code == GCU_MISSING) {
             checkGCUExists(*results);
         } else if (code == GCU_AS_MISSING) {
             checkGCUHasAddressSpace(*results);
         } else if (code == USED_IO_NOT_BOUND) {
             checkOperandBindings(*results);
         } else if (code == DIFFERENT_PORT_FOR_JUMP_AND_CALL) {
             checkJumpAndCallOperandBindings(*results);
         } else if (code == PC_PORT_MISSING) {
             checkProgramCounterPort(*results);
         } else if (code == RA_PORT_MISSING) {
             checkReturnAddressPort(*results);
         } else if (code == PC_AND_RA_PORTS_HAVE_UNEQUAL_WIDTH) {
             checkRAPortHasSameWidthAsPCPort(*results);
         } else if (code == IMEM_ADDR_WIDTH_DIFFERS_FROM_RA_AND_PC) {
             checkIMemAddrWidth(*results);
         } else if (code == FU_PORT_MISSING) {
             checkFUConnections(*results);
         } else {
             assert(false);
         }
     }
  
     return results;
 }

References assert, checkFUConnections(), checkGCUExists(), checkGCUHasAddressSpace(), checkIMemAddrWidth(), checkJumpAndCallOperandBindings(), checkOperandBindings(), checkProgramCounterPort(), checkRAPortHasSameWidthAsPCPort(), checkReturnAddressPort(), DIFFERENT_PORT_FOR_JUMP_AND_CALL, FU_PORT_MISSING, GCU_AS_MISSING, GCU_MISSING, IMEM_ADDR_WIDTH_DIFFERS_FROM_RA_AND_PC, PC_AND_RA_PORTS_HAVE_UNEQUAL_WIDTH, PC_PORT_MISSING, RA_PORT_MISSING, and USED_IO_NOT_BOUND.

Referenced by LLVMBackend::compile(), ProgrammabilityValidator::ProgrammabilityValidator(), and ProGe::ProcessorGenerator::validateMachine().

Here is the call graph for this function:

Member Data Documentation

◆ machine_

const TTAMachine::Machine& MachineValidator::machine_

private

The machine to validate.

Definition at line 98 of file MachineValidator.hh.

Referenced by checkFUConnections(), checkGCUExists(), checkGCUHasAddressSpace(), checkIMemAddrWidth(), checkJumpAndCallOperandBindings(), checkOperandBindings(), checkProgramCounterPort(), checkRAPortHasSameWidthAsPCPort(), and checkReturnAddressPort().

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

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Enumeration Documentation

◆ ErrorCode

Constructor & Destructor Documentation

◆ MachineValidator()

◆ ~MachineValidator()

Member Function Documentation

◆ checkFUConnections()

◆ checkGCUExists()

◆ checkGCUHasAddressSpace()

◆ checkIMemAddrWidth()

◆ checkJumpAndCallOperandBindings()

◆ checkOperandBindings()

◆ checkProgramCounterPort()

◆ checkRAPortHasSameWidthAsPCPort()

◆ checkReturnAddressPort()

◆ validate()

Member Data Documentation

◆ machine_