MachineConnectivityCheck Class Reference

#include <MachineConnectivityCheck.hh>

Inheritance diagram for MachineConnectivityCheck:

Collaboration diagram for MachineConnectivityCheck:

Public Types
typedef std::set< const TTAMachine::Port *, const TTAMachine::MachinePart::Comparator >	PortSet
typedef std::set< TTAMachine::Bus *, const TTAMachine::MachinePart::Comparator >	BusSet
typedef std::set< const TTAMachine::FunctionUnit *, const TTAMachine::MachinePart::Comparator >	FUSet

Public Member Functions
virtual bool	check (const TTAMachine::Machine &mach, MachineCheckResults &results) const
	MachineConnectivityCheck ()
virtual	~MachineConnectivityCheck ()

Static Public Member Functions
static bool	isConnected (const TTAMachine::Port &sourcePort, const TTAMachine::Port &destinationPort, const TTAMachine::Guard *guard=NULL)
static bool	isConnected (const TTAMachine::BaseRegisterFile &sourceRF, const TTAMachine::Port &destPort)
static bool	isConnected (const TTAMachine::BaseRegisterFile &sourceRF, const TTAMachine::BaseRegisterFile &destRF, const TTAMachine::Guard *guard=NULL)
static bool	isConnectedWithBothGuards (const TTAMachine::BaseRegisterFile &sourceRF, const TTAMachine::BaseRegisterFile &destRF, std::pair< const TTAMachine::RegisterFile *, int > guardReg)
static bool	isConnected (const TTAMachine::Port &sourcePort, const TTAMachine::RegisterFile &destRF)
static bool	isConnected (const TTAMachine::BaseRegisterFile &sourceRF, const TTAMachine::FunctionUnit &destFU)
static bool	isConnected (PortSet sourcePorts, PortSet destinationPorts, const TTAMachine::Guard *guard=NULL)
static bool	isConnected (const std::set< TTAMachine::Port * > ports, const TTAMachine::Bus &bus)
static bool	isConnected (const TTAMachine::Bus &bus, const TTAMachine::Port &port)
static bool	isConnected (const TTAMachine::Port &port, const TTAMachine::Bus &bus)
static bool	canWriteAllImmediates (TTAMachine::Port &destPort)
static bool	canTransportImmediate (const TTAProgram::TerminalImmediate &immediate, const TTAMachine::BaseRegisterFile &destRF, const TTAMachine::Guard *guard=NULL)
static bool	canTransportImmediate (const TTAProgram::TerminalImmediate &immediate, const TTAMachine::Port &destinationPort, const TTAMachine::Guard *guard=NULL)
static bool	canTransportImmediate (const TTAProgram::TerminalImmediate &immediate, PortSet destinationPorts, const TTAMachine::Guard *guard=NULL)
static bool	canTransportImmediate (const TTAProgram::TerminalImmediate &immediate, const TTAMachine::Bus &bus)
static bool	canTransportMove (const MoveNode &moveNode, const TTAMachine::Machine &machine, bool ignoreGuard=false)
static bool	canBypass (const MoveNode &src, const MoveNode &user, const TTAMachine::Machine &targetMachine)
static bool	rfConnected (const TTAMachine::RegisterFile &rf)
static bool	fromRfConnected (const TTAMachine::BaseRegisterFile &brf)
static bool	toRfConnected (const TTAMachine::RegisterFile &brf)
static std::set< const TTAMachine::Bus * >	connectedSourceBuses (const TTAMachine::Port &port)
static std::set< const TTAMachine::Bus * >	connectedDestinationBuses (const TTAMachine::Port &port)
static void	appendConnectedSourceBuses (const TTAMachine::Port &port, std::set< const TTAMachine::Bus * > &buses)
static void	appendConnectedDestinationBuses (const TTAMachine::Port &port, std::set< const TTAMachine::Bus * > &buses)
static void	appendConnectedSourceBuses (const TTAMachine::Unit &unit, std::set< const TTAMachine::Bus * > &buses)
static void	appendConnectedDestinationBuses (const TTAMachine::Unit &unit, std::set< const TTAMachine::Bus * > &buses)
static std::set< const TTAMachine::RegisterFile *, TTAMachine::MachinePart::Comparator >	tempRegisterFiles (const TTAMachine::Machine &machine)
static int	requiredImmediateWidth (bool signExtension, const TTAProgram::TerminalImmediate &source, const TTAMachine::Machine &mach)
static bool	busConnectedToPort (const TTAMachine::Bus &bus, const TTAMachine::Port &port)
static bool	busConnectedToRF (const TTAMachine::Bus &bus, const TTAMachine::Unit &destRF)
static bool	busConnectedToFU (const TTAMachine::Bus &bus, const TTAMachine::FunctionUnit &fu, const TCEString &opName, int opIndex)
static bool	busConnectedToAnyFU (const TTAMachine::Bus &bus, const MoveNode &moveNode)
static bool	busConnectedToDestination (const TTAMachine::Bus &bus, const MoveNode &moveNode)
static int	totalConnectionCount (const TTAMachine::Machine &mach)
static PortSet	findPossibleDestinationPorts (const TTAMachine::Machine &mach, const MoveNode &node)
static PortSet	findPossibleSourcePorts (const TTAMachine::Machine &mach, const MoveNode &node)
static int	canSourceWriteToAnyDestinationPort (const MoveNode &src, PortSet &ports, bool ignoreGuard=false)
static bool	canAnyPortWriteToDestination (PortSet &ports, const MoveNode &dest)
static PortSet	findWritePorts (const TTAMachine::Unit &rf)
static PortSet	findReadPorts (const TTAMachine::Unit &rf)
static BusSet	findRoutes (TTAMachine::Port &port1, TTAMachine::Port &port2)
static bool	canBypassOpToDst (const TTAMachine::Machine &mach, const TCEString &opName, int outIndex, const MoveNode &mn)
static FUSet	copyOpFUs (const TTAMachine::Machine &mach, const MoveNode &mn)
static bool	hasConditionalMoves (const TTAMachine::Machine &mach, const std::set< int > &rfWidths)
static void	addAnnotatedFUs (std::set< TCEString > &candidateFUs, const TTAProgram::Move &m, TTAProgram::ProgramAnnotation::Id id)
static bool	isConnectedToDifferentlyConnectedRFs (const TTAMachine::RegisterFile &rf)
static bool	isEquallyConnected (const TTAMachine::BaseRegisterFile &RF1, const TTAMachine::BaseRegisterFile &RF2)
static std::pair< bool, bool >	hasBothGuards (const TTAMachine::Bus *bus, std::pair< const TTAMachine::RegisterFile *, int > guardReg)
static std::set< const TTAMachine::RegisterFile * >	needRegCopiesDueReadPortConflicts (const TTAMachine::Machine &machine)
static int	maxLIMMCount (const TTAMachine::Machine &targetMachine)
static int	maxSIMMCount (const TTAMachine::Machine &targetMachine)
static bool	isPortApplicableToWidths (const TTAMachine::Port &port, std::set< int > widths)
static std::pair< int, int >	shortImmBits (std::set< const TTAMachine::Bus * > &buses)
static std::pair< int, int >	immBits (const TTAMachine::RegisterFile &rf)
static bool	needsRegisterCopiesDueImmediateOperands (const TTAMachine::Machine &mach)
static std::pair< int, int >	immBits (const TTAMachine::Machine &mach)
static void	shortImmBits (std::set< const TTAMachine::Bus * > &buses, std::pair< int, int > &)
static int	operandWidth (const TTAMachine::HWOperation &hwop, int index)
static bool	raConnected (const TTAMachine::Machine &machine)

Protected Member Functions
	MachineConnectivityCheck (const std::string &shortDesc_)

Private Types
typedef std::pair< const TTAMachine::Port *, const TTAMachine::Port * >	PortPortPair
typedef std::pair< const TTAMachine::BaseRegisterFile *, const TTAMachine::BaseRegisterFile * >	RfRfPair
typedef std::pair< const TTAMachine::BaseRegisterFile *, const TTAMachine::Port * >	RfPortPair
typedef std::pair< const TTAMachine::Port *, const TTAMachine::BaseRegisterFile * >	PortRfPair
typedef std::map< PortPortPair, bool >	PortPortBoolMap
typedef std::map< RfRfPair, bool >	RfRfBoolMap
typedef std::map< RfPortPair, bool >	RfPortBoolMap
typedef std::map< PortRfPair, bool >	PortRfBoolMap

Static Private Attributes
static PortPortBoolMap	portPortCache_
static RfRfBoolMap	rfRfCache_
static RfPortBoolMap	rfPortCache_
static PortRfBoolMap	portRfCache_

Additional Inherited Members
Private Member Functions inherited from MachineCheck
virtual std::string	shortDescription () const
virtual std::string	description () const
virtual bool	canFix (const TTAMachine::Machine &mach) const
virtual std::string	fix (TTAMachine::Machine &mach) const
virtual	~MachineCheck ()
	MachineCheck (const std::string &shortDesc_)

Detailed Description

Base class for machine interconnection connectivity checks.

Provides helper functions that are useful for many derived checks.

Definition at line 69 of file MachineConnectivityCheck.hh.

Member Typedef Documentation

BusSet

typedef std::set<TTAMachine::Bus*, const TTAMachine::MachinePart::Comparator> MachineConnectivityCheck::BusSet

Definition at line 74 of file MachineConnectivityCheck.hh.

FUSet

typedef std::set<const TTAMachine::FunctionUnit*, const TTAMachine::MachinePart::Comparator> MachineConnectivityCheck::FUSet

Definition at line 76 of file MachineConnectivityCheck.hh.

PortPortBoolMap

typedef std::map<PortPortPair,bool> MachineConnectivityCheck::PortPortBoolMap

private

Definition at line 314 of file MachineConnectivityCheck.hh.

PortPortPair

typedef std::pair<const TTAMachine::Port*,const TTAMachine::Port*> MachineConnectivityCheck::PortPortPair

private

Definition at line 303 of file MachineConnectivityCheck.hh.

PortRfBoolMap

typedef std::map<PortRfPair,bool> MachineConnectivityCheck::PortRfBoolMap

private

Definition at line 317 of file MachineConnectivityCheck.hh.

PortRfPair

typedef std::pair<const TTAMachine::Port*, const TTAMachine::BaseRegisterFile*> MachineConnectivityCheck::PortRfPair

private

Definition at line 312 of file MachineConnectivityCheck.hh.

PortSet

typedef std::set<const TTAMachine::Port*, const TTAMachine::MachinePart::Comparator> MachineConnectivityCheck::PortSet

Definition at line 72 of file MachineConnectivityCheck.hh.

RfPortBoolMap

typedef std::map<RfPortPair,bool> MachineConnectivityCheck::RfPortBoolMap

private

Definition at line 316 of file MachineConnectivityCheck.hh.

RfPortPair

typedef std::pair<const TTAMachine::BaseRegisterFile*, const TTAMachine::Port*> MachineConnectivityCheck::RfPortPair

private

Definition at line 309 of file MachineConnectivityCheck.hh.

RfRfBoolMap

typedef std::map<RfRfPair,bool> MachineConnectivityCheck::RfRfBoolMap

private

Definition at line 315 of file MachineConnectivityCheck.hh.

RfRfPair

typedef std::pair<const TTAMachine::BaseRegisterFile*, const TTAMachine::BaseRegisterFile*> MachineConnectivityCheck::RfRfPair

private

Definition at line 306 of file MachineConnectivityCheck.hh.

Constructor & Destructor Documentation

MachineConnectivityCheck() [1/2]

MachineConnectivityCheck::MachineConnectivityCheck

(

)

Constructor for using this generic class directly.

Definition at line 67 of file MachineConnectivityCheck.cc.

                                                   : 
    MachineCheck("Common helper functionality for connectivity checks.") {
}

~MachineConnectivityCheck()

MachineConnectivityCheck::~MachineConnectivityCheck ( )

virtual

Destructor.

Definition at line 74 of file MachineConnectivityCheck.cc.

                                                    {
}

MachineConnectivityCheck() [2/2]

MachineConnectivityCheck::MachineConnectivityCheck ( const std::string &  shortDesc_ )

protected

Constructor for deriving.

Parameters

shortDesc

The short description of the check.

Definition at line 82 of file MachineConnectivityCheck.cc.

                                 : MachineCheck(shortDesc_) {
}

Member Function Documentation

addAnnotatedFUs()

void MachineConnectivityCheck::addAnnotatedFUs ( std::set< TCEString > &  candidateFUs, const TTAProgram::Move &  m, TTAProgram::ProgramAnnotation::Id  id  )

static

Definition at line 1859 of file MachineConnectivityCheck.cc.

                                      {
    
    const int annotationCount = m.annotationCount(id);
    for (int i = 0; i < annotationCount; ++i) {
        std::string candidateFU = m.annotation(i, id).stringValue();
        candidateFUs.insert(candidateFU);
    }
}

References TTAProgram::AnnotatedInstructionElement::annotation(), TTAProgram::AnnotatedInstructionElement::annotationCount(), and TTAProgram::ProgramAnnotation::stringValue().

Referenced by InputFUBroker::allAvailableResources(), OutputFUBroker::allAvailableResources(), busConnectedToAnyFU(), findPossibleDestinationPorts(), and findPossibleSourcePorts().

Here is the call graph for this function:

appendConnectedDestinationBuses() [1/2]

void MachineConnectivityCheck::appendConnectedDestinationBuses ( const TTAMachine::Port &  port, std::set< const TTAMachine::Bus * > &  buses  )

static

Appends destination buses connected to a given (output) port.

Parameters

port	The port to check
buses	Set where the connected buses are appended.

Definition at line 818 of file MachineConnectivityCheck.cc.

                                                                     {
 
    const TTAMachine::Socket* outputS = port.outputSocket();
 
    if (outputS != NULL) {
        for (int i = 0; i < outputS->segmentCount(); ++i) {
            buses.insert(outputS->segment(i)->parentBus());
        }
    }
}

References TTAMachine::Port::outputSocket(), TTAMachine::Segment::parentBus(), TTAMachine::Socket::segment(), and TTAMachine::Socket::segmentCount().

Referenced by appendConnectedDestinationBuses(), MachineInfo::canEncodeImmediateInteger(), connectedDestinationBuses(), fromRfConnected(), isConnected(), isConnected(), isConnected(), isConnected(), isConnectedWithBothGuards(), and isEquallyConnected().

Here is the call graph for this function:

appendConnectedDestinationBuses() [2/2]

void MachineConnectivityCheck::appendConnectedDestinationBuses ( const TTAMachine::Unit &  unit, std::set< const TTAMachine::Bus * > &  buses  )

static

Appends destination buses connected to a given unit.

Destination buses are the buses the unit can write data to.

Parameters

unit	The unit to check
buses	Set where the connected buses are appended.

Definition at line 857 of file MachineConnectivityCheck.cc.

                                                                     {
 
    for (int p = 0; p < unit.portCount(); ++p) {
        appendConnectedDestinationBuses(*unit.port(p), buses);
    }
}

References appendConnectedDestinationBuses(), TTAMachine::Unit::port(), and TTAMachine::Unit::portCount().

Here is the call graph for this function:

appendConnectedSourceBuses() [1/2]

void MachineConnectivityCheck::appendConnectedSourceBuses ( const TTAMachine::Port &  port, std::set< const TTAMachine::Bus * > &  buses  )

static

Appends source buses connected to a given (input) port.

Parameters

port	The port to check
buses	Set where the connected buses are appended.

Definition at line 799 of file MachineConnectivityCheck.cc.

                                                                     {
 
    const TTAMachine::Socket* inputS = port.inputSocket();
 
    if (inputS != NULL) {
        for (int i = 0; i < inputS->segmentCount(); ++i) {
            buses.insert(inputS->segment(i)->parentBus());
        }
    }
}

References TTAMachine::Port::inputSocket(), TTAMachine::Segment::parentBus(), TTAMachine::Socket::segment(), and TTAMachine::Socket::segmentCount().

Referenced by appendConnectedSourceBuses(), canTransportImmediate(), canTransportImmediate(), connectedSourceBuses(), immBits(), isConnected(), isConnected(), isConnected(), isConnected(), isConnectedWithBothGuards(), isEquallyConnected(), BFEarlyGuardBypass::operator()(), and toRfConnected().

Here is the call graph for this function:

appendConnectedSourceBuses() [2/2]

void MachineConnectivityCheck::appendConnectedSourceBuses ( const TTAMachine::Unit &  unit, std::set< const TTAMachine::Bus * > &  buses  )

static

Appends source buses connected to a given unit.

Source buses are the buses the unit can read data from.

Parameters

unit	The unit to check
buses	Set where the connected buses are appended.

Definition at line 839 of file MachineConnectivityCheck.cc.

                                                                     {
 
    for (int p = 0; p < unit.portCount(); ++p) {
        const TTAMachine::Port& port = *unit.port(p);
        appendConnectedSourceBuses(port, buses);
    }
}

References appendConnectedSourceBuses(), TTAMachine::Unit::port(), and TTAMachine::Unit::portCount().

Here is the call graph for this function:

busConnectedToAnyFU()

bool MachineConnectivityCheck::busConnectedToAnyFU ( const TTAMachine::Bus &  bus, const MoveNode &  moveNode  )

static

Definition at line 1344 of file MachineConnectivityCheck.cc.

                                                        {
 
    const TTAProgram::Move& move = moveNode.move();
    TTAProgram::TerminalFUPort* tfp = 
        static_cast<TTAProgram::TerminalFUPort*>(&move.destination());
    int opIndex = tfp->operationIndex();
 
    ProgramOperation& po = moveNode.destinationOperation();
    auto fu = po.scheduledFU();
/*
    for (int i = 0; i < po.inputMoveCount(); i++ ) {
        MoveNode& inputNode = po.inputMove(i);
        if (inputNode.isAssigned()) {
            unit = inputNode.move().destination().port().parentUnit();
            break;
        }
    }
    if (unit == NULL) { // goto over this would have been better
        for (int i = 0; i < po.outputMoveCount(); i++ ) {
            MoveNode& outputNode = po.outputMove(i);
            if (outputNode.isAssigned()) {
                if (outputNode.isSourceOperation() &&
                    &outputNode.sourceOperation() == &po) {
                    unit = outputNode.move().source().port().parentUnit();
                    break;
                } else {
                    assert (!outputNode.move().isUnconditional());
                    assert (&outputNode.guardOperation() == &po);
                    const TTAMachine::Guard& guard =
                        outputNode.move().guard().guard();
                    const TTAMachine::PortGuard* pg =
                        dynamic_cast<const TTAMachine::PortGuard*>(&guard);
                    assert(pg); // todo: throw?
                    unit = pg->port()->parentUnit();
                    break;
                }
            }
        }
    }
*/
 
    Operation& op = move.destination().hintOperation();
    TCEString opName = StringTools::stringToLower(op.name());
 
    if (fu != NULL) {
//        const FunctionUnit* fu = dynamic_cast<const FunctionUnit*>(unit);
        assert(fu != NULL);
        return busConnectedToFU(bus, *fu, opName, opIndex);
    }
 
    // check if the move has a candidate FU set which limits the
    // choice of FU for the node
    std::set<TCEString> candidateFUs;
    std::set<TCEString> allowedFUs;
 
    addAnnotatedFUs(
        candidateFUs, move, 
        TTAProgram::ProgramAnnotation::ANN_CONN_CANDIDATE_UNIT_DST);
    addAnnotatedFUs(
        allowedFUs, move, 
        TTAProgram::ProgramAnnotation::ANN_ALLOWED_UNIT_DST);
 
    TTAMachine::ControlUnit* gcu = bus.machine()->controlUnit();
    if (candidateFUs.empty() || AssocTools::containsKey(
            candidateFUs,gcu->name())) {
        if (busConnectedToFU(bus, *gcu, opName, opIndex)) {
            return true;
        }
    }
 
 
    const TTAMachine::Machine::FunctionUnitNavigator& fuNav = 
        bus.machine()->functionUnitNavigator();
    for (int i = 0; i < fuNav.count(); i++) {
        TTAMachine::FunctionUnit& fu = *fuNav.item(i);
        if (!candidateFUs.empty() && !AssocTools::containsKey(
                candidateFUs,fu.name())) {
            continue;
        }
        if (!allowedFUs.empty() && !AssocTools::containsKey(
                allowedFUs,fu.name())) {
            continue;
        }
        if (busConnectedToFU(bus, fu, opName, opIndex)) {
            return true;
        }
    }
    return false;
}

References addAnnotatedFUs(), TTAProgram::ProgramAnnotation::ANN_ALLOWED_UNIT_DST, TTAProgram::ProgramAnnotation::ANN_CONN_CANDIDATE_UNIT_DST, assert, busConnectedToFU(), AssocTools::containsKey(), TTAMachine::Machine::controlUnit(), TTAMachine::Machine::Navigator< ComponentType >::count(), TTAProgram::Move::destination(), MoveNode::destinationOperation(), TTAMachine::Machine::functionUnitNavigator(), TTAProgram::Terminal::hintOperation(), TTAMachine::Machine::Navigator< ComponentType >::item(), TTAMachine::Component::machine(), MoveNode::move(), TTAMachine::Component::name(), Operation::name(), TTAProgram::TerminalFUPort::operationIndex(), ProgramOperation::scheduledFU(), and StringTools::stringToLower().

Referenced by busConnectedToDestination().

Here is the call graph for this function:

busConnectedToDestination()

bool MachineConnectivityCheck::busConnectedToDestination ( const TTAMachine::Bus &  bus, const MoveNode &  moveNode  )

static

Definition at line 1436 of file MachineConnectivityCheck.cc.

                              {
    const TTAProgram::Move& move = moveNode.move();
    if (move.destination().isGPR()) {
        TTAMachine::Unit& destRF = 
            *move.destination().port().parentUnit();
        return MachineConnectivityCheck::busConnectedToRF(bus, destRF);
        
    }
    if (move.destination().isFUPort()) {
        if (move.destination().isRA()) {
            const TTAMachine::ControlUnit* gcu = bus.machine()->controlUnit();
            const TTAMachine::SpecialRegisterPort* ra = 
                gcu->returnAddressPort();
            // TODO:: machineconcctivitycheck, bus connected to port?
            if (MachineConnectivityCheck::busConnectedToPort(bus, *ra)) {
                return true;
            }
        } else {
            return MachineConnectivityCheck::busConnectedToAnyFU(
                bus, moveNode);
        }
    }
    return false;
}

References busConnectedToAnyFU(), busConnectedToPort(), busConnectedToRF(), TTAMachine::Machine::controlUnit(), TTAProgram::Move::destination(), TTAProgram::Terminal::isFUPort(), TTAProgram::Terminal::isGPR(), TTAProgram::Terminal::isRA(), TTAMachine::Component::machine(), MoveNode::move(), TTAMachine::Port::parentUnit(), TTAProgram::Terminal::port(), and TTAMachine::ControlUnit::returnAddressPort().

Referenced by BusBroker::canTransportImmediate().

Here is the call graph for this function:

busConnectedToFU()

bool MachineConnectivityCheck::busConnectedToFU ( const TTAMachine::Bus &  bus, const TTAMachine::FunctionUnit &  fu, const TCEString &  opName, int  opIndex  )

static

Definition at line 1322 of file MachineConnectivityCheck.cc.

                                          {
 
    if (fu.hasOperationLowercase(opName)) {
        const TTAMachine::HWOperation& hwop = 
            *fu.operationLowercase(opName);
        
        TTAMachine::FUPort* port = hwop.port(opIndex);
        if (port == NULL){
            throw IllegalMachine(
                __FILE__, __LINE__, __func__, 
                "Target is missing operand bindings for: "
                + opName);
        }
        return MachineConnectivityCheck::busConnectedToPort(bus, *port);
    }
    return false;
}

References __func__, busConnectedToPort(), TTAMachine::FunctionUnit::hasOperationLowercase(), TTAMachine::FunctionUnit::operationLowercase(), and TTAMachine::HWOperation::port().

Referenced by busConnectedToAnyFU().

Here is the call graph for this function:

busConnectedToPort()

bool MachineConnectivityCheck::busConnectedToPort ( const TTAMachine::Bus &  bus, const TTAMachine::Port &  port  )

static

Definition at line 1293 of file MachineConnectivityCheck.cc.

                                                          {
    const TTAMachine::Socket* inputS = port.inputSocket();
    if (inputS != NULL) {
        for (int i = 0; i < inputS->segmentCount(); ++i) {
            if (inputS->segment(i)->parentBus() == &bus) {
                return true;
            }
        }
    }
    return false;
}

References TTAMachine::Port::inputSocket(), TTAMachine::Segment::parentBus(), TTAMachine::Socket::segment(), and TTAMachine::Socket::segmentCount().

Referenced by busConnectedToDestination(), busConnectedToFU(), busConnectedToRF(), MachineInfo::supportsBoolRegisterGuardedJumps(), MachineInfo::supportsPortGuardedJump(), and MachineInfo::supportsPortGuardedJumps().

Here is the call graph for this function:

busConnectedToRF()

bool MachineConnectivityCheck::busConnectedToRF ( const TTAMachine::Bus &  bus, const TTAMachine::Unit &  destRF  )

static

Returns true if bus is connected to the RF's any writing port.

Definition at line 1309 of file MachineConnectivityCheck.cc.

                                                            {
    for (int i = 0; i < destRF.portCount(); i++) {
        const TTAMachine::Port& port = *destRF.port(i);
        if (MachineConnectivityCheck::busConnectedToPort(bus, port)) {
            return true;
        }
    }
    return false;
}

References busConnectedToPort(), TTAMachine::Unit::port(), and TTAMachine::Unit::portCount().

Referenced by busConnectedToDestination().

Here is the call graph for this function:

canAnyPortWriteToDestination()

bool MachineConnectivityCheck::canAnyPortWriteToDestination ( PortSet &  ports, const MoveNode &  dest  )

static

Definition at line 1833 of file MachineConnectivityCheck.cc.

                                                {
 
    if (sourcePorts.empty()) {
        return false;
    }
 
    PortSet destPorts = findPossibleDestinationPorts(
            *(*sourcePorts.begin())->parentUnit()->machine(), dest);
    return MachineConnectivityCheck::isConnected(sourcePorts, destPorts);
}

References findPossibleDestinationPorts(), and isConnected().

Referenced by RegisterRenamer::findConnectedRFs(), and BF2Scheduler::possibleTempRegRFs().

Here is the call graph for this function:

canBypass()

bool MachineConnectivityCheck::canBypass ( const MoveNode &  src, const MoveNode &  user, const TTAMachine::Machine &  targetMachine  )

static

Definition at line 1792 of file MachineConnectivityCheck.cc.

                                            {
 
    MachineConnectivityCheck::PortSet destinationPorts = 
        MachineConnectivityCheck::findPossibleDestinationPorts(
            targetMachine, user);
 
    int trueVal = 1;
    if (destinationPorts.empty()) {
        return false;
    }
 
    if (src.isSourceConstant()) {
        TTAProgram::TerminalImmediate* imm = 
            static_cast<TTAProgram::TerminalImmediate*>(
                &src.move().source());
        if (MachineConnectivityCheck::canTransportImmediate(
                *imm, destinationPorts)) {
            return true; // can transfer via short imm.
        } else {
            trueVal = -1; // mayby through LIMM?
        }
    }
 
    PortSet sourcePorts = findPossibleSourcePorts(targetMachine, src);
 
    // TODO: Why cannot move.guard return pointer which is NULL if
    // unconditional?
    const TTAProgram::Move& userMove = user.move();
    if (MachineConnectivityCheck::isConnected(
            sourcePorts, destinationPorts, 
            userMove.isUnconditional() ? NULL : &userMove.guard().guard())) {
        return trueVal;
    }
 
    return false;
}

References canTransportImmediate(), findPossibleDestinationPorts(), findPossibleSourcePorts(), TTAProgram::Move::guard(), TTAProgram::MoveGuard::guard(), isConnected(), MoveNode::isSourceConstant(), TTAProgram::Move::isUnconditional(), MoveNode::move(), and TTAProgram::Move::source().

Referenced by BFEarlyBypasser::operator()().

Here is the call graph for this function:

canBypassOpToDst()

bool MachineConnectivityCheck::canBypassOpToDst ( const TTAMachine::Machine &  mach, const TCEString &  opName, int  outIndex, const MoveNode &  mn  )

static

Definition at line 2078 of file MachineConnectivityCheck.cc.

                        {
 
    PortSet sourcePorts;
 
    const TTAMachine::Machine::FunctionUnitNavigator& fuNav =
        mach.functionUnitNavigator();
    for (auto fu: fuNav) {
        if (fu->hasOperation(opName)) {
            TTAMachine::HWOperation* hwop = fu->operation(opName);
            sourcePorts.insert(hwop->port(outIndex));
        }
    }
 
    MachineConnectivityCheck::PortSet destinationPorts =
        MachineConnectivityCheck::findPossibleDestinationPorts(mach, mn);
 
    const TTAProgram::Move& move = mn.move();
    return MachineConnectivityCheck::isConnected(
        sourcePorts, destinationPorts,
        (move.isUnconditional()) ?
        nullptr : &move.guard().guard());
}

References findPossibleDestinationPorts(), TTAMachine::Machine::functionUnitNavigator(), TTAProgram::Move::guard(), TTAProgram::MoveGuard::guard(), isConnected(), TTAProgram::Move::isUnconditional(), MoveNode::move(), and TTAMachine::HWOperation::port().

Here is the call graph for this function:

canSourceWriteToAnyDestinationPort()

int MachineConnectivityCheck::canSourceWriteToAnyDestinationPort ( const MoveNode &  src, PortSet &  destinationPorts, bool  ignoreGuard = false  )

static

1 = can write 0 = cannot write -1 = can write through limm

Definition at line 1757 of file MachineConnectivityCheck.cc.

                                                                      {
 
    int trueVal = 1;
    if (destinationPorts.empty()) {
        return false;
    }
 
    if (src.isSourceConstant()) {
        TTAProgram::TerminalImmediate* imm = 
            static_cast<TTAProgram::TerminalImmediate*>(
                &src.move().source());
        if (MachineConnectivityCheck::canTransportImmediate(
                *imm, destinationPorts)) {
            return true; // can transfer via short imm.
        } else {
            trueVal = -1; // mayby through LIMM?
        }
    }
 
    PortSet sourcePorts = findPossibleSourcePorts(
            *(*destinationPorts.begin())->parentUnit()->machine(), src);
 
    // TODO: Why cannot move.guard return pointer which is NULL if unconditional?
    const TTAProgram::Move& move = src.move();
    if (MachineConnectivityCheck::isConnected(
            sourcePorts, destinationPorts,
            (ignoreGuard || move.isUnconditional()) ?
            NULL : &move.guard().guard())) {
        return trueVal;
    }
 
    return false;
}

References canTransportImmediate(), findPossibleSourcePorts(), TTAProgram::Move::guard(), TTAProgram::MoveGuard::guard(), isConnected(), MoveNode::isSourceConstant(), TTAProgram::Move::isUnconditional(), MoveNode::move(), and TTAProgram::Move::source().

Referenced by canTransportMove(), copyOpFUs(), BUBasicBlockScheduler::findBypassDestinations(), RegisterRenamer::findConnectedRFs(), BFLateBypasses::operator()(), and BF2Scheduler::possibleTempRegRFs().

Here is the call graph for this function:

canTransportImmediate() [1/4]

bool MachineConnectivityCheck::canTransportImmediate ( const TTAProgram::TerminalImmediate &  immediate, const TTAMachine::BaseRegisterFile &  destRF, const TTAMachine::Guard *  guard = NULL  )

static

Checks whether an immediate with given width can be transported to the destination register file.

Parameters

destRF	The destination RF.
immediate	The immediate to transport.

Returns

True if there is at least one path between the given ports.

Definition at line 181 of file MachineConnectivityCheck.cc.

                        {
 
    std::set<const TTAMachine::Bus*> buses;
    MachineConnectivityCheck::appendConnectedSourceBuses(destRF, buses);
 
    for (auto bus : buses) {
        int requiredBits = 
            MachineConnectivityCheck::requiredImmediateWidth(
                bus->signExtends(), immediate, *destRF.machine());
        if (bus->immediateWidth() < requiredBits) {
            continue;
        }
        
        if (guard == NULL) {
            return true;
        } else {
            if (bus->hasGuard(*guard)) {
                return true;
            }
        }
    }
    return false;
}

References appendConnectedSourceBuses(), TTAMachine::Component::machine(), and requiredImmediateWidth().

Referenced by RegisterCopyAdder::addConnectionRegisterCopies(), RegisterCopyAdder::addConnectionRegisterCopiesImmediate(), canBypass(), canSourceWriteToAnyDestinationPort(), canTransportImmediate(), canTransportImmediate(), and BFOptimization::immCountPreventsScheduling().

Here is the call graph for this function:

canTransportImmediate() [2/4]

bool MachineConnectivityCheck::canTransportImmediate ( const TTAProgram::TerminalImmediate &  immediate, const TTAMachine::Bus &  bus  )

static

Checks whether an immediate with given width can be transported on the bus.

Parameters

immediate	The immediate to transport.
bus	The bus.

Returns

True if the bus can transport the immediate as inline.

Definition at line 268 of file MachineConnectivityCheck.cc.

                              {
 
    int requiredBits =
    MachineConnectivityCheck::requiredImmediateWidth(
        bus.signExtends(), immediate, *bus.machine());
    if (bus.immediateWidth() >= requiredBits) {
        return true;
    } else {
        return false;
    }
}

References TTAMachine::Bus::immediateWidth(), TTAMachine::Component::machine(), requiredImmediateWidth(), and TTAMachine::Bus::signExtends().

Here is the call graph for this function:

canTransportImmediate() [3/4]

bool MachineConnectivityCheck::canTransportImmediate ( const TTAProgram::TerminalImmediate &  immediate, const TTAMachine::Port &  destinationPort, const TTAMachine::Guard *  guard = NULL  )

static

Checks whether an immediate with given width can be transported to the destination port.

Parameters

immediate	The immediate to transport.
destinationPort	The destination port.

Returns

True if there is at least one path between the given ports.

Definition at line 217 of file MachineConnectivityCheck.cc.

                        {
 
    std::set<const TTAMachine::Bus*> buses;
    MachineConnectivityCheck::appendConnectedSourceBuses(
        destinationPort, buses);
 
    for (auto i = buses.begin(); i != buses.end(); ++i) {
        const TTAMachine::Bus& bus = **i;
 
        if (!canTransportImmediate(immediate, bus)) {
            continue;
        }
        if (guard == NULL) {
            return true;
        } else {
            if (bus.hasGuard(*guard)) {
                return true;
            }
        }
    }
    return false;
}

References appendConnectedSourceBuses(), canTransportImmediate(), and TTAMachine::Bus::hasGuard().

Here is the call graph for this function:

canTransportImmediate() [4/4]

bool MachineConnectivityCheck::canTransportImmediate ( const TTAProgram::TerminalImmediate &  immediate, PortSet  destinationPorts, const TTAMachine::Guard *  guard = NULL  )

static

Definition at line 244 of file MachineConnectivityCheck.cc.

                        {
 
    for (PortSet::iterator i =
             destinationPorts.begin();
         i != destinationPorts.end(); i++) {
        if (canTransportImmediate(immediate, **i, guard)) {
            return true;
        }
    }
    return false;
}

References canTransportImmediate().

Here is the call graph for this function:

canTransportMove()

bool MachineConnectivityCheck::canTransportMove ( const MoveNode &  moveNode, const TTAMachine::Machine &  machine, bool  ignoreGuard = false  )

static

Definition at line 1846 of file MachineConnectivityCheck.cc.

                      {
    PortSet destinationPorts =
        MachineConnectivityCheck::findPossibleDestinationPorts(
            machine,moveNode);
 
    return MachineConnectivityCheck::canSourceWriteToAnyDestinationPort(
        moveNode, destinationPorts, ignoreGuard);
}

References canSourceWriteToAnyDestinationPort(), findPossibleDestinationPorts(), and machine.

Referenced by BFOptimization::canBeScheduled(), and BFTryRemoveGuard::operator()().

Here is the call graph for this function:

canWriteAllImmediates()

bool MachineConnectivityCheck::canWriteAllImmediates ( TTAMachine::Port &  destPort )

static

Checks if there is a way to write immediate directly from bus or from immu to the given port

Parameters

port	Port where to check immediate write ability.

First check if there is a bus that can transfer the immediates

Definition at line 1194 of file MachineConnectivityCheck.cc.

                                                              {
    /** First check if there is a bus that can transfer the immediates */
    int portWidth = destPort.width();
    int sextImm = 0;
    int zextImm = 0;
 
    Socket& socket = *destPort.inputSocket();
    
    // check immediates from buses
    for (int i = 0; i < socket.segmentCount(); ++i) {
        auto bus = socket.segment(i)->parentBus();
        int immw = bus->immediateWidth();
        if (bus->signExtends()) {
            sextImm = std::max(immw, sextImm);
        } else {
            zextImm = std::max(immw, zextImm);
        }
        if (immw >= portWidth) {
            return true;
        }
    }
 
    // then check directly connected imm units
    const TTAMachine::Machine& mach = *destPort.parentUnit()->machine();
    TTAMachine::Machine::ImmediateUnitNavigator iuNav = 
        mach.immediateUnitNavigator();
    
    for (int i = 0; i < iuNav.count(); i++) {
        ImmediateUnit& iu = *iuNav.item(i);
        int immw = iu.width();
        if (isConnected(iu, destPort)) {
            if (iu.signExtends()) {
                sextImm = std::max(immw, sextImm);
            } else {
                zextImm = std::max(immw, zextImm);
            }
        }
    }
 
    auto widestImms = immBits(mach);
    // wide zext imm not needed if has one bit wider sext imm.
    if (widestImms.first > sextImm ||
        (widestImms.second > zextImm && (sextImm-1) < widestImms.second)) {
        return false;
    }
    return true;
}

References TTAMachine::Machine::Navigator< ComponentType >::count(), immBits(), TTAMachine::Machine::immediateUnitNavigator(), TTAMachine::Bus::immediateWidth(), TTAMachine::Port::inputSocket(), isConnected(), TTAMachine::Machine::Navigator< ComponentType >::item(), TTAMachine::Component::machine(), TTAMachine::Segment::parentBus(), TTAMachine::Port::parentUnit(), TTAMachine::Socket::segment(), TTAMachine::Socket::segmentCount(), TTAMachine::ImmediateUnit::signExtends(), TTAMachine::BaseRegisterFile::width(), and TTAMachine::Port::width().

Referenced by needsRegisterCopiesDueImmediateOperands().

Here is the call graph for this function:

check()

bool MachineConnectivityCheck::check ( const TTAMachine::Machine &  mach, MachineCheckResults &  results  ) const

virtual

Dummy implementation for the pure virtual method MachineCheck::check().

The implementation is needed for generation of Python bindings, as Boost.Python cannot create instances of abstract base classes.

Implements MachineCheck.

Definition at line 115 of file MachineConnectivityCheck.cc.

                                            {
    assert(0);
}

References assert.

connectedDestinationBuses()

std::set< const TTAMachine::Bus * > MachineConnectivityCheck::connectedDestinationBuses ( const TTAMachine::Port &  port )

static

Returns all buses the given port can write to

Parameters

port	The port to check.

Returns

The set of buses connected to the port.

Definition at line 784 of file MachineConnectivityCheck.cc.

                                {
 
    std::set<const TTAMachine::Bus*> buses;
    appendConnectedDestinationBuses(port,buses);
    return buses;
}

References appendConnectedDestinationBuses().

Referenced by immBits(), isConnected(), and toRfConnected().

Here is the call graph for this function:

connectedSourceBuses()

std::set< const TTAMachine::Bus * > MachineConnectivityCheck::connectedSourceBuses ( const TTAMachine::Port &  port )

static

Returns all buses the given port can read from.

Parameters

port	The port to check.

Returns

The set of buses connected to the port.

Definition at line 769 of file MachineConnectivityCheck.cc.

                                {
 
    std::set<const TTAMachine::Bus*> buses;
    appendConnectedSourceBuses(port,buses);
    return buses;
}

References appendConnectedSourceBuses().

Referenced by ImmediateAnalyzer::analyzeImmediateCapabilitiesForOperation(), fromRfConnected(), and isConnected().

Here is the call graph for this function:

copyOpFUs()

MachineConnectivityCheck::FUSet MachineConnectivityCheck::copyOpFUs ( const TTAMachine::Machine &  mach, const MoveNode &  mn  )

static

Find FU which has copy op that can be used to schedule this move.

Prioritizes FUs which can schedule the move directly with one copy op. If none found, then fives FU which has copy op and can recursively be used with later copy. If none found at all, returns empty set.

Definition at line 2043 of file MachineConnectivityCheck.cc.

                        {
 
    // with these, single copy op is enough
    FUSet suitableFUs;
    // with these, have to use multiple copy ops or copy+regcopy
    FUSet partiallySuitableFUs;
 
    std::string opName = "COPY";
    const TTAProgram::Move& move = mn.move();
    auto destinationPorts = findPossibleDestinationPorts(mach, mn);
 
    for (auto fu: mach.functionUnitNavigator()) {
        PortSet copyOutPorts;
        PortSet copyTriggerPorts;
        if (fu->hasOperation(opName)) {
            TTAMachine::HWOperation* hwop = fu->operation(opName);
            copyOutPorts.insert(hwop->port(2));
            copyTriggerPorts.insert(hwop->port(1));
            if (MachineConnectivityCheck::isConnected(
                    copyOutPorts, destinationPorts,
                    (move.isUnconditional()) ?
                    nullptr : &move.guard().guard())) {
                partiallySuitableFUs.insert(fu);
                if (canSourceWriteToAnyDestinationPort(
                        mn, copyTriggerPorts)) {
                    suitableFUs.insert(fu);
                }
            }
        }
    }
    return suitableFUs.empty() ? partiallySuitableFUs : suitableFUs;
}

References canSourceWriteToAnyDestinationPort(), findPossibleDestinationPorts(), TTAMachine::Machine::functionUnitNavigator(), TTAProgram::Move::guard(), TTAProgram::MoveGuard::guard(), isConnected(), TTAProgram::Move::isUnconditional(), MoveNode::move(), and TTAMachine::HWOperation::port().

Referenced by BFScheduleBU::operator()().

Here is the call graph for this function:

findPossibleDestinationPorts()

MachineConnectivityCheck::PortSet MachineConnectivityCheck::findPossibleDestinationPorts ( const TTAMachine::Machine &  mach, const MoveNode &  node  )

static

Definition at line 1477 of file MachineConnectivityCheck.cc.

                          {
    PortSet res;
    if (node.isScheduled()) {
        res.insert(&node.move().destination().port());
        return res;
    }
 
    if (node.isDestinationOperation()) {
        TTAMachine::Machine::FunctionUnitNavigator nav = 
            mach.functionUnitNavigator();
        ProgramOperation& po = node.destinationOperation();
        std::set<TCEString> allowedFUNames;
 
        if (po.isAnyNodeAssigned()) {
            for (int i = 0; i < po.inputMoveCount(); i++) {
                MoveNode& mn = po.inputMove(i);
                if (mn.isScheduled()) {
                    allowedFUNames.insert(
                        mn.move().destination().port().parentUnit()->name());
                }
            }
 
            for (int i = 0; i < po.outputMoveCount(); i++) {
                MoveNode& mn = po.outputMove(i);
                if (mn.isScheduled()) {
                    if (mn.isSourceOperation() && &mn.sourceOperation() == &po) {
                        allowedFUNames.insert(
                            mn.move().source().port().parentUnit()->name());
                    } else {
                        if (mn.isGuardOperation() &&
                            &mn.guardOperation() == &po) {
                            const TTAMachine::Guard& guard =
                                mn.move().guard().guard();
                            const TTAMachine::PortGuard* pg =
                                dynamic_cast<const TTAMachine::PortGuard*>(&guard);
                            assert(pg); // todo: throw?
                            const TTAMachine::Unit* u = pg->port()->parentUnit();
                            allowedFUNames.insert(u->name());
                        }
                    }
                }
            }
        }
 
        std::set<TCEString> candidateFUs;
        std::set<TCEString> allowedFUs;
    
        addAnnotatedFUs(
            candidateFUs, node.move(), 
            TTAProgram::ProgramAnnotation::ANN_CONN_CANDIDATE_UNIT_DST);
        addAnnotatedFUs(
            allowedFUs, node.move(),
            TTAProgram::ProgramAnnotation::ANN_ALLOWED_UNIT_DST);
 
        if (!candidateFUs.empty()) {
            if (allowedFUNames.empty()) {
                allowedFUNames = candidateFUs;
            } else {
                std::set<TCEString> tmp;
                SetTools::intersection(allowedFUNames, candidateFUs,tmp);
                allowedFUNames = tmp;
            }
 
        }
    
        if (!allowedFUs.empty()) {
            if (allowedFUNames.empty()) {
                allowedFUNames = allowedFUs;
            } else {
                std::set<TCEString> tmp;
                SetTools::intersection(allowedFUNames, allowedFUs,tmp);
                allowedFUNames = tmp;
            }
        }
        
        for (int i = 0; i <= nav.count(); i++) {
            TTAMachine::FunctionUnit* fu;
            if (i == nav.count()) { // GCU is not on fu navigator
                fu = mach.controlUnit();
            } else {
                fu = nav.item(i);
            }
            
            if (!allowedFUNames.empty() && !AssocTools::containsKey(
                    allowedFUNames, fu->name())) {
                continue;
            }
            if (fu->hasOperation(po.operation().name())) {
                TTAMachine::HWOperation* hwop = 
                    fu->operation(po.operation().name());
                res.insert(
                    hwop->port(node.move().destination().operationIndex()));
            }
        }
        return res;
    }
 
    if (node.move().destination().isRA()) {
        res.insert(mach.controlUnit()->returnAddressPort());
        return res;
    }
 
    // destination is register
    if (!node.move().destination().isGPR()) {
        std::cerr << "node should have dest as reg: " << 
            node.toString() << std::endl;
    }
    assert(node.move().destination().isGPR());
    return findWritePorts(
        *node.move().destination().port().parentUnit());
}

References addAnnotatedFUs(), TTAProgram::ProgramAnnotation::ANN_ALLOWED_UNIT_DST, TTAProgram::ProgramAnnotation::ANN_CONN_CANDIDATE_UNIT_DST, assert, AssocTools::containsKey(), TTAMachine::Machine::controlUnit(), TTAMachine::Machine::Navigator< ComponentType >::count(), TTAProgram::Move::destination(), MoveNode::destinationOperation(), findWritePorts(), TTAMachine::Machine::functionUnitNavigator(), TTAProgram::Move::guard(), TTAProgram::MoveGuard::guard(), MoveNode::guardOperation(), TTAMachine::FunctionUnit::hasOperation(), ProgramOperation::inputMove(), ProgramOperation::inputMoveCount(), SetTools::intersection(), ProgramOperation::isAnyNodeAssigned(), MoveNode::isDestinationOperation(), TTAProgram::Terminal::isGPR(), MoveNode::isGuardOperation(), TTAProgram::Terminal::isRA(), MoveNode::isScheduled(), MoveNode::isSourceOperation(), TTAMachine::Machine::Navigator< ComponentType >::item(), MoveNode::move(), TTAMachine::Component::name(), Operation::name(), ProgramOperation::operation(), TTAMachine::FunctionUnit::operation(), TTAProgram::Terminal::operationIndex(), ProgramOperation::outputMove(), ProgramOperation::outputMoveCount(), TTAMachine::BaseFUPort::parentUnit(), TTAMachine::Port::parentUnit(), TTAMachine::PortGuard::port(), TTAProgram::Terminal::port(), TTAMachine::HWOperation::port(), TTAMachine::ControlUnit::returnAddressPort(), TTAProgram::Move::source(), MoveNode::sourceOperation(), and MoveNode::toString().

Referenced by canAnyPortWriteToDestination(), canBypass(), canBypassOpToDst(), canTransportMove(), copyOpFUs(), and BFEarlyGuardBypass::operator()().

Here is the call graph for this function:

findPossibleSourcePorts()

MachineConnectivityCheck::PortSet MachineConnectivityCheck::findPossibleSourcePorts ( const TTAMachine::Machine &  mach, const MoveNode &  node  )

static

Definition at line 1676 of file MachineConnectivityCheck.cc.

                                                         {
    PortSet res;
    if (node.isScheduled() && !node.isSourceConstant()) {
        res.insert(&node.move().source().port());
        return res;
    }
 
    if (node.isSourceOperation()) {
        TTAMachine::Machine::FunctionUnitNavigator nav = 
            mach.functionUnitNavigator();
        ProgramOperation& po = node.sourceOperation();
 
        std::set<TCEString> candidateFUs;
        std::set<TCEString> allowedFUs;
    
        addAnnotatedFUs(candidateFUs, node.move(), 
        TTAProgram::ProgramAnnotation::ANN_CONN_CANDIDATE_UNIT_SRC);
        addAnnotatedFUs(allowedFUs, node.move(),
        TTAProgram::ProgramAnnotation::ANN_ALLOWED_UNIT_SRC);
 
        for (int i = 0; i < nav.count(); i++) {
            TTAMachine::FunctionUnit* fu = nav.item(i);
            if (!allowedFUs.empty() && !AssocTools::containsKey(
                    allowedFUs, fu->name())) {
                continue;
            }
            if (!candidateFUs.empty() && !AssocTools::containsKey(
                    candidateFUs, fu->name())) {
                continue;
            }
            
            if (fu->hasOperation(po.operation().name())) {
                TTAMachine::HWOperation* hwop = 
                    fu->operation(po.operation().name());
                res.insert(
                    hwop->port(node.move().source().operationIndex()));
            }
        }
        return res;
    }
 
    if (node.isSourceVariable()) {
        // source is register
        return findReadPorts(
            *node.move().source().port().parentUnit());
    }
 
    // consider only long immediates here.
    if (node.isSourceConstant()) {
        TTAProgram::TerminalImmediate& imm = 
            static_cast<TTAProgram::TerminalImmediate&>(node.move().source());
        TTAMachine::Machine::ImmediateUnitNavigator nav = 
            mach.immediateUnitNavigator();
        for (int i = 0; i < nav.count(); i++) {
            TTAMachine::ImmediateUnit* iu = nav.item(i);
            if (iu->width() >= 
                MachineConnectivityCheck::requiredImmediateWidth(
                    iu->extensionMode() == Machine::SIGN, imm, mach)) {
                for (int i = 0; i < iu->portCount(); i++) {
                    TTAMachine::Port* port = iu->port(i);
                    assert(port->isOutput());
                    res.insert(port);
                }
            }
        }
        return res;
    }
 
    if (node.move().source().isRA()) {
        res.insert(mach.controlUnit()->returnAddressPort());
    }
 
    return res;
}

References addAnnotatedFUs(), TTAProgram::ProgramAnnotation::ANN_ALLOWED_UNIT_SRC, TTAProgram::ProgramAnnotation::ANN_CONN_CANDIDATE_UNIT_SRC, assert, AssocTools::containsKey(), TTAMachine::Machine::controlUnit(), TTAMachine::Machine::Navigator< ComponentType >::count(), TTAMachine::ImmediateUnit::extensionMode(), findReadPorts(), TTAMachine::Machine::functionUnitNavigator(), TTAMachine::FunctionUnit::hasOperation(), TTAMachine::Machine::immediateUnitNavigator(), TTAMachine::Port::isOutput(), TTAProgram::Terminal::isRA(), MoveNode::isScheduled(), MoveNode::isSourceConstant(), MoveNode::isSourceOperation(), MoveNode::isSourceVariable(), TTAMachine::Machine::Navigator< ComponentType >::item(), MoveNode::move(), TTAMachine::Component::name(), Operation::name(), ProgramOperation::operation(), TTAMachine::FunctionUnit::operation(), TTAProgram::Terminal::operationIndex(), TTAMachine::Port::parentUnit(), TTAProgram::Terminal::port(), TTAMachine::BaseRegisterFile::port(), TTAMachine::HWOperation::port(), TTAMachine::Unit::portCount(), requiredImmediateWidth(), TTAMachine::ControlUnit::returnAddressPort(), TTAMachine::Machine::SIGN, TTAProgram::Move::source(), MoveNode::sourceOperation(), and TTAMachine::BaseRegisterFile::width().

Referenced by canBypass(), and canSourceWriteToAnyDestinationPort().

Here is the call graph for this function:

findReadPorts()

MachineConnectivityCheck::PortSet MachineConnectivityCheck::findReadPorts ( const TTAMachine::Unit &  rf )

static

Definition at line 1604 of file MachineConnectivityCheck.cc.

                                                                {
    PortSet res;
    for (int i = 0; i < rf.portCount(); i++) {
        TTAMachine::Port* port = rf.port(i);
        if (port->isOutput()) {
            res.insert(port);
        }
    }
    return res;
}

References TTAMachine::Port::isOutput(), TTAMachine::Unit::port(), and TTAMachine::Unit::portCount().

Referenced by RegisterRenamer::findConnectedRFs(), findPossibleSourcePorts(), and BF2Scheduler::possibleTempRegRFs().

Here is the call graph for this function:

findRoutes()

MachineConnectivityCheck::BusSet MachineConnectivityCheck::findRoutes ( TTAMachine::Port &  port1, TTAMachine::Port &  port2  )

static

Returns busses that connects the given ports.

Definition at line 1661 of file MachineConnectivityCheck.cc.

                           {
 
    MachineConnectivityCheck::BusSet result;
    const Machine& mach = *port1.parentUnit()->machine();
    for (Bus* bus : mach.busNavigator()) {
        if (isConnected(port1, *bus) && isConnected(port2, *bus)) {
            result.insert(bus);
        }
    }
    return result;
}

References TTAMachine::Machine::busNavigator(), isConnected(), TTAMachine::Component::machine(), and TTAMachine::Port::parentUnit().

Here is the call graph for this function:

findWritePorts()

MachineConnectivityCheck::PortSet MachineConnectivityCheck::findWritePorts ( const TTAMachine::Unit &  rf )

static

Definition at line 1592 of file MachineConnectivityCheck.cc.

                                                                 {
    PortSet res;
    for (int i = 0; i < rf.portCount(); i++) {
        const TTAMachine::Port* port = rf.port(i);
        if (port->isInput()) {
            res.insert(port);
        }
    }
    return res;
}

References TTAMachine::Port::isInput(), TTAMachine::Unit::port(), and TTAMachine::Unit::portCount().

Referenced by RegisterRenamer::findConnectedRFs(), findPossibleDestinationPorts(), and BF2Scheduler::possibleTempRegRFs().

Here is the call graph for this function:

fromRfConnected()

bool MachineConnectivityCheck::fromRfConnected ( const TTAMachine::BaseRegisterFile &  brf )

static

Checks whether there is a connection from the given Register file or Immediate unit to all FU's and control unit of the machine.

It both this and toRfConnected() returns true, then this FU can be used as the only register file to be used for reduced connectivity-register copying.

Parameters

brf	Register file or immediate unit being checked.

Returns

true if this RF can write to all ports af all FU's.

Definition at line 502 of file MachineConnectivityCheck.cc.

                                           {
 
    int width = brf.width();
    bool isVectorRegs = width > 32;
    TTAMachine::Machine& mach = *brf.machine();
    TTAMachine::Machine::FunctionUnitNavigator fuNav = 
        mach.functionUnitNavigator();
    
 
    std::set<const TTAMachine::Bus*> rfBuses;
 
    for (int i = 0; i < brf.portCount(); i++) {
        const TTAMachine::Port& port = *brf.port(i);
        if (port.outputSocket() != NULL) {
            appendConnectedDestinationBuses(port, rfBuses);
        }
    }
 
    std::set<int> widths;
    widths.insert(brf.width());
 
    auto widthsExt = widths;
    if (width == 32) {
        widthsExt.insert(1);
        widthsExt.insert(8);
        widthsExt.insert(16);
    }
    if (width == 1) {
        widthsExt.insert(32);
    }
 
    // check connections to function units
    for (auto fu: fuNav) {
        for (int j = 0; j < fu->portCount(); j++ ) {
            Port& port = *fu->port(j);
            // connections from RF to FU's
            if (port.inputSocket() != NULL &&
                isPortApplicableToWidths(port, widthsExt)) {
                std::set<const TTAMachine::Bus*> sharedBuses;
                SetTools::intersection(
                    rfBuses, connectedSourceBuses(port), sharedBuses);
                if (sharedBuses.size() == 0) {
                    return false;
                }
            }
        }
    } 
 
    // no need to transfer data from vector regs to control unit.
    if (isVectorRegs) {
        return true;
    }
 
    // check connections to control unit
    TTAMachine::ControlUnit& cu = *mach.controlUnit();
    for (int i = 0; i < cu.portCount(); i++ ) {
        Port& port = *cu.port(i);
 
        // connections from RF to CU
        if (port.inputSocket() != NULL &&
            isPortApplicableToWidths(port, widths)) {
            std::set<const TTAMachine::Bus*> sharedBuses;
            SetTools::intersection(
                rfBuses, connectedSourceBuses(port), sharedBuses);
            if (sharedBuses.size() == 0) {
                return false;
            }
        }
    }
    return true;
}

References appendConnectedDestinationBuses(), connectedSourceBuses(), TTAMachine::Machine::controlUnit(), TTAMachine::Machine::functionUnitNavigator(), TTAMachine::Port::inputSocket(), SetTools::intersection(), isPortApplicableToWidths(), TTAMachine::Component::machine(), TTAMachine::Port::outputSocket(), TTAMachine::BaseRegisterFile::port(), TTAMachine::FunctionUnit::port(), TTAMachine::Unit::portCount(), and TTAMachine::BaseRegisterFile::width().

Referenced by rfConnected().

Here is the call graph for this function:

hasBothGuards()

std::pair< bool, bool > MachineConnectivityCheck::hasBothGuards ( const TTAMachine::Bus *  bus, std::pair< const TTAMachine::RegisterFile *, int >  guardReg  )

static

Definition at line 1986 of file MachineConnectivityCheck.cc.

                                                                         {
    bool trueOK = false;
    bool falseOK = false;
 
    for (int gi = 0; gi < bus->guardCount(); gi++) {
        const TTAMachine::Guard* guard = bus->guard(gi);
        const TTAMachine::RegisterGuard* rg =
            dynamic_cast<const TTAMachine::RegisterGuard*>(guard);
        if (rg != NULL) {
            if (rg->registerFile() == guardReg.first &&
                rg->registerIndex() == guardReg.second) {
                if (rg->isInverted()) {
                    falseOK = true;
                } else {
                    trueOK = true;
                }
                if (falseOK && trueOK) {
                    return std::pair<bool, bool>(true, true);
                }
            }
        }
    }
    return std::pair<bool, bool>(trueOK, falseOK);
}

References TTAMachine::Bus::guard(), TTAMachine::Bus::guardCount(), TTAMachine::Guard::isInverted(), TTAMachine::RegisterGuard::registerFile(), and TTAMachine::RegisterGuard::registerIndex().

Referenced by isConnectedWithBothGuards().

Here is the call graph for this function:

hasConditionalMoves()

bool MachineConnectivityCheck::hasConditionalMoves ( const TTAMachine::Machine &  mach, const std::set< int > &  rfWidths  )

static

Definition at line 1879 of file MachineConnectivityCheck.cc.

                                                                {
 
    const Machine::RegisterFileNavigator regNav =
        mach.registerFileNavigator();
 
    std::set<std::pair<const RegisterFile*,int> > allGuardRegs;
    const Machine::BusNavigator& busNav = mach.busNavigator();
 
    // first just collect all guard registers.
    for (int bi = 0; bi < busNav.count(); ++bi) {
        Bus* bus = busNav.item(bi);
        for (int gi = 0; gi < bus->guardCount(); gi++) {
            const Guard* guard = bus->guard(gi);
            const TTAMachine::RegisterGuard* rg =
                dynamic_cast<const RegisterGuard*>(guard);
            if (rg != NULL) {
                allGuardRegs.insert(
                    std::pair<const RegisterFile*,int>(rg->registerFile(),
                                                       rg->registerIndex()));
            }
        }
    }
 
    if (allGuardRegs.empty()) {
        return false;
    }
 
    // then check for the connections.
    for (int i = 0; i < regNav.count(); i++) {
        const TTAMachine::RegisterFile* srf = regNav.item(i);
        for (int j = 0; j < regNav.count(); j++) {
            const TTAMachine::RegisterFile* drf = regNav.item(i);
            int width = drf->width();
 
            // if we do not care about RFs of this size
            if (!rfWidths.empty() &&
                !AssocTools::containsKey(rfWidths, width)) {
                continue;
            }
 
            for (std::set<std::pair<const RegisterFile*,int> >::iterator k =
                     allGuardRegs.begin(); k != allGuardRegs.end(); k++) {
                if (!isConnectedWithBothGuards(*srf, *drf, *k)) {
                    return false;
                }
            }
        }
    }
    return true;
}

References TTAMachine::Machine::busNavigator(), AssocTools::containsKey(), TTAMachine::Machine::Navigator< ComponentType >::count(), TTAMachine::Bus::guard(), TTAMachine::Bus::guardCount(), isConnectedWithBothGuards(), TTAMachine::Machine::Navigator< ComponentType >::item(), TTAMachine::RegisterGuard::registerFile(), TTAMachine::Machine::registerFileNavigator(), TTAMachine::RegisterGuard::registerIndex(), and TTAMachine::BaseRegisterFile::width().

Referenced by TDGen::TDGen().

Here is the call graph for this function:

immBits() [1/2]

std::pair< int, int > MachineConnectivityCheck::immBits ( const TTAMachine::Machine &  mach )

static

Definition at line 594 of file MachineConnectivityCheck.cc.

                                   {
    std::pair<int, int> rv;
    std::set<const TTAMachine::Bus*> buses;
    for (auto b: mach.busNavigator()) {
        buses.insert(b);
    }
    shortImmBits(buses, rv);
    return rv;
}

References TTAMachine::Machine::busNavigator(), and shortImmBits().

Here is the call graph for this function:

immBits() [2/2]

std::pair< int, int > MachineConnectivityCheck::immBits ( const TTAMachine::RegisterFile &  rf )

static

Definition at line 620 of file MachineConnectivityCheck.cc.

                                      {
    auto mach = rf.machine();
    std::pair<int, int> rv(0,0);
    std::set<const TTAMachine::Bus*> rfBuses;
 
    if (mach == nullptr) {
        return rv;
    }
 
    for (int i = 0; i < rf.portCount(); i++) {
        auto port = rf.port(i);
        if (port->inputSocket() != NULL) {
            appendConnectedSourceBuses(*port, rfBuses);
        }
    }
    shortImmBits(rfBuses, rv);
 
    // then check LIMM connections.
    for (auto iu: mach->immediateUnitNavigator()) {
        int w = iu->width();
        for (int j = 0; j < iu->portCount(); j++ ) {
            Port& port = *iu->port(j);
            if (port.outputSocket() == nullptr)
                continue;
 
            std::set<const TTAMachine::Bus*> sharedBuses;
            SetTools::intersection(
                rfBuses, connectedDestinationBuses(port),sharedBuses);
            // TODO: check bus widths.
            if (sharedBuses.size() != 0) {
                if (iu->signExtends()) {
                    rv.first = std::max(rv.first, w);
                } else {
                    rv.second = std::max(rv.second, w);
                }
            }
        }
    }
    return rv;
}

References appendConnectedSourceBuses(), connectedDestinationBuses(), SetTools::intersection(), TTAMachine::Component::machine(), TTAMachine::Port::outputSocket(), TTAMachine::BaseRegisterFile::port(), TTAMachine::Unit::portCount(), and shortImmBits().

Referenced by canWriteAllImmediates(), shortImmBits(), and toRfConnected().

Here is the call graph for this function:

isConnected() [1/9]

bool MachineConnectivityCheck::isConnected ( const std::set< TTAMachine::Port * >  ports, const TTAMachine::Bus &  bus  )

static

Returns true if all ports are connected to the bus.

Definition at line 1647 of file MachineConnectivityCheck.cc.

                                                                    {
     for (const auto& port : ports) {
         if (!isConnected(bus, *port)) {
             return false;
         }
     }
     return true;
 }

References isConnected().

Here is the call graph for this function:

isConnected() [2/9]

bool MachineConnectivityCheck::isConnected ( const TTAMachine::BaseRegisterFile &  sourceRF, const TTAMachine::BaseRegisterFile &  destRF, const TTAMachine::Guard *  guard = NULL  )

static

Checks whether there is a connection from some outport port of a register file or immediate unit into some input port of the given target register file or immediate unit.

Parameters

sourceRF	Source RF/Immediate unit.
destRF	Source RF/Immediate unit.

Returns

True if there is at least one connection from any of the output ports of the source RF/Imm unit into the destination RF.

Definition at line 334 of file MachineConnectivityCheck.cc.

                                  {
    
    RfRfBoolMap::const_iterator
        i = rfRfCache_.find(RfRfPair(&sourceRF, &destRF));
    if (i != rfRfCache_.end()) {
        if (i->second == false || guard == NULL) {
            return i->second;
        }
    }
    std::set<const TTAMachine::Bus*> srcBuses;
    appendConnectedDestinationBuses(sourceRF, srcBuses);
 
    std::set<const TTAMachine::Bus*> dstBuses;
    appendConnectedSourceBuses(destRF, dstBuses);
 
    std::set<const TTAMachine::Bus*> sharedBuses;
    SetTools::intersection(srcBuses, dstBuses, sharedBuses);
    if (sharedBuses.size() > 0) {
        rfRfCache_[RfRfPair(&sourceRF,&destRF)] = true;
        if (guard == NULL) {
            return true;
        }
 
        for (std::set<const TTAMachine::Bus*>::iterator i = sharedBuses.begin();
             i != sharedBuses.end(); i++) {
            if ((*i)->hasGuard(*guard)) {
                return true;
            }
        }
        return false; // bus found but lacks the guards
    } else {
        rfRfCache_[RfRfPair(&sourceRF,&destRF)] = false;
        return false;
    }
}

References appendConnectedDestinationBuses(), appendConnectedSourceBuses(), SetTools::intersection(), and rfRfCache_.

Here is the call graph for this function:

isConnected() [3/9]

bool MachineConnectivityCheck::isConnected ( const TTAMachine::BaseRegisterFile &  sourceRF, const TTAMachine::FunctionUnit &  destFU  )

static

Checks whether there is a connection from some outport port of a register file or immediate unit into some input port of the given target function unit.

Parameters

sourceRF	Source RF/Immediate unit.
destFU	Destination FU.

Returns

True if there is at least one connection from any of the output ports of the source RF/Imm unit into the destination FU.

Definition at line 384 of file MachineConnectivityCheck.cc.

                                          {
    
    std::set<const TTAMachine::Bus*> srcBuses;
    appendConnectedDestinationBuses(sourceRF, srcBuses);
 
    std::set<const TTAMachine::Bus*> dstBuses;
    appendConnectedSourceBuses(destFU, dstBuses);
 
    std::set<const TTAMachine::Bus*> sharedBuses;
    SetTools::intersection(srcBuses, dstBuses, sharedBuses);
    return (sharedBuses.size() > 0);
}

References appendConnectedDestinationBuses(), appendConnectedSourceBuses(), and SetTools::intersection().

Here is the call graph for this function:

isConnected() [4/9]

bool MachineConnectivityCheck::isConnected ( const TTAMachine::BaseRegisterFile &  sourceRF, const TTAMachine::Port &  destPort  )

static

Checks whether there is a connection from some outport port of a register file or immediate unit into the specified port.

Parameters

sourceRF	Source RF/Immediate unit.
destPort	The destination port.

Returns

True if there is at least one connection from any of the output ports of the source RF/Imm unit into the destination port.

Definition at line 292 of file MachineConnectivityCheck.cc.

                                    {
 
    RfPortBoolMap::const_iterator
        i = rfPortCache_.find(RfPortPair(&sourceRF, &destPort));
    if (i != rfPortCache_.end()) {
        return i->second;
    }    
    std::set<const TTAMachine::Bus*> destBuses = connectedSourceBuses(destPort);
    std::set<const TTAMachine::Bus*> srcBuses;
 
    for (int i = 0; i < sourceRF.portCount(); i++) {
        const TTAMachine::Port& port = *sourceRF.port(i);
        if (port.outputSocket() != NULL) {
            appendConnectedDestinationBuses(port, srcBuses);
        }
    }
 
    std::set<const TTAMachine::Bus*> sharedBuses;
    SetTools::intersection(
        srcBuses, destBuses, sharedBuses);
    if (sharedBuses.size() > 0) {
        rfPortCache_[RfPortPair(&sourceRF,&destPort)] = true;
        return true;
    } else {
        rfPortCache_[RfPortPair(&sourceRF,&destPort)] = false;
        return false;
    }
}

References appendConnectedDestinationBuses(), connectedSourceBuses(), SetTools::intersection(), TTAMachine::Port::outputSocket(), TTAMachine::BaseRegisterFile::port(), TTAMachine::Unit::portCount(), and rfPortCache_.

Here is the call graph for this function:

isConnected() [5/9]

bool MachineConnectivityCheck::isConnected ( const TTAMachine::Bus &  bus, const TTAMachine::Port &  port  )

static

Returns true if there is connection between the port and the bus.

Definition at line 1619 of file MachineConnectivityCheck.cc.

                                    {
     std::vector<const Socket*> sockets{
         port.inputSocket(), port.outputSocket()};
 
     for (const Socket* socket : sockets) {
         if (socket != nullptr && socket->isConnectedTo(bus)) {
             return true;
         }
     }
     return false;
 }

References TTAMachine::Port::inputSocket(), and TTAMachine::Port::outputSocket().

Here is the call graph for this function:

isConnected() [6/9]

bool MachineConnectivityCheck::isConnected ( const TTAMachine::Port &  port, const TTAMachine::Bus &  bus  )

static

Returns true if there is connection between the port and the bus.

Definition at line 1637 of file MachineConnectivityCheck.cc.

                               {
     return isConnected(bus, port);
 }

References isConnected().

Here is the call graph for this function:

isConnected() [7/9]

bool MachineConnectivityCheck::isConnected ( const TTAMachine::Port &  sourcePort, const TTAMachine::Port &  destinationPort, const TTAMachine::Guard *  guard = NULL  )

static

Checks whether there is a connection between two ports.

Parameters

sourcePort	The source (rf/fu) port.
destinationPort	The destination (rf/fu) port.

Returns

True if there is at least one path between the given ports.

Definition at line 128 of file MachineConnectivityCheck.cc.

                        {
 
    // TODO: replace this cache's second value(bool) with set of buses.
    PortPortBoolMap::const_iterator
        i = portPortCache_.find(PortPortPair(&sourcePort, &destinationPort));
    if (i != portPortCache_.end()) {
        if (i->second == false || guard == NULL) {
            return i->second;
        }
    }
    std::set<const TTAMachine::Bus*> sourceBuses;
    MachineConnectivityCheck::appendConnectedDestinationBuses(
        sourcePort, sourceBuses);
 
    std::set<const TTAMachine::Bus*> destinationBuses;
    MachineConnectivityCheck::appendConnectedSourceBuses(
        destinationPort, destinationBuses);
 
    std::set<const TTAMachine::Bus*> sharedBuses;
    SetTools::intersection(sourceBuses, destinationBuses, sharedBuses);
    if (sharedBuses.size() > 0) {
        portPortCache_[PortPortPair(&sourcePort,&destinationPort)] = true;
 
        if (guard == NULL) {
            return true;
        }
 
        for (std::set<const TTAMachine::Bus*>::iterator i = sharedBuses.begin();
             i != sharedBuses.end(); i++) {
            if ((*i)->hasGuard(*guard)) {
                return true;
            }
        }
             
        return false; // bus found but lacks the guards
    } else {
        portPortCache_[PortPortPair(&sourcePort,&destinationPort)] = false;
        return false;
    }
}

References appendConnectedDestinationBuses(), appendConnectedSourceBuses(), SetTools::intersection(), and portPortCache_.

Referenced by RegisterCopyAdder::addConnectionRegisterCopies(), RegisterCopyAdder::addConnectionRegisterCopies(), RegisterCopyAdder::addConnectionRegisterCopiesImmediate(), ImmediateAnalyzer::analyzeImmediateCapabilitiesForOperation(), canAnyPortWriteToDestination(), canBypass(), canBypassOpToDst(), canSourceWriteToAnyDestinationPort(), canWriteAllImmediates(), CopyingDelaySlotFiller::collectMoves(), copyOpFUs(), RegisterCopyAdder::countAndAddConnectionRegisterCopiesToRR(), ProGe::RV32MicroCodeGenerator::findConnectedBusses(), findRoutes(), isConnected(), isConnected(), isConnected(), isConnectedToDifferentlyConnectedRFs(), MachineAnalysis::MachineAnalysis(), BF2Scheduler::possibleTempRegRFs(), and raConnected().

Here is the call graph for this function:

isConnected() [8/9]

bool MachineConnectivityCheck::isConnected ( const TTAMachine::Port &  sourcePort, const TTAMachine::RegisterFile &  destRF  )

static

Checks whether there is a connection from specified port into some input port of a register file.

Parameters

sourcePort	The source port.
destRF	Destination register file.

Returns

True if there exists at least one connection from source to any input port of destination register file.

Definition at line 410 of file MachineConnectivityCheck.cc.

                                          {
 
    PortRfBoolMap::const_iterator
        i = portRfCache_.find(PortRfPair(&sourcePort, &destRF));
    if (i != portRfCache_.end()) {
        return i->second;
    }
 
    std::set<const TTAMachine::Bus*> sourceBuses =
        connectedDestinationBuses(sourcePort);
    std::set<const TTAMachine::Bus*> destBuses;
 
    for (int i = 0; i < destRF.portCount(); i++) {
        const TTAMachine::Port& port = *destRF.port(i);
        if (port.inputSocket() != NULL) {
            appendConnectedSourceBuses(port, destBuses);
        }
    }
    
    std::set<const TTAMachine::Bus*> sharedBuses;
    SetTools::intersection(sourceBuses, destBuses, sharedBuses);
 
    if (sharedBuses.size() > 0) {
        portRfCache_[PortRfPair(&sourcePort,&destRF)] = true;
        return true;
    } else {
        portRfCache_[PortRfPair(&sourcePort,&destRF)] = false;
        return false;
    }
}

References appendConnectedSourceBuses(), connectedDestinationBuses(), TTAMachine::Port::inputSocket(), SetTools::intersection(), TTAMachine::BaseRegisterFile::port(), TTAMachine::Unit::portCount(), and portRfCache_.

Here is the call graph for this function:

isConnected() [9/9]

bool MachineConnectivityCheck::isConnected ( PortSet  sourcePorts, PortSet  destinationPorts, const TTAMachine::Guard *  guard = NULL  )

static

Definition at line 88 of file MachineConnectivityCheck.cc.

                        {
    for (PortSet::iterator i =
             sourcePorts.begin();
         i != sourcePorts.end(); i++) {
        const TTAMachine::Port& sport = **i;
        for (PortSet::iterator j =
                 destinationPorts.begin();
             j != destinationPorts.end(); j++) {
            if (isConnected(sport, **j, guard)) {
                return true;
            }
        }
    }
    return false;
}

References isConnected().

Here is the call graph for this function:

isConnectedToDifferentlyConnectedRFs()

bool MachineConnectivityCheck::isConnectedToDifferentlyConnectedRFs ( const TTAMachine::RegisterFile &  rf )

static

Checks if given RF is connected to differently connected RFs, to know if we need to reserve temp registers for transfers between the two RFs.

TODO: This isn't always needed: there is no need to reserve a register from an RF if it is only connected to RFs with a subset of the connectivity it offers.

Definition at line 875 of file MachineConnectivityCheck.cc.

                                      {
    auto regNav = rf.machine()->registerFileNavigator();
    for (auto rf2: regNav) {
        if ((rf2 != &rf) &&
            (isConnected(rf,*rf2) || isConnected(*rf2,rf)) &&
            !isEquallyConnected(rf, *rf2) &&
            ((rf.width() <= 32 && rf2->width() <= 32) ||
             (rf.width() == rf2->width()))) {
            return true;
        }
    }
    return false;
}

References isConnected(), isEquallyConnected(), TTAMachine::Component::machine(), TTAMachine::Machine::registerFileNavigator(), and TTAMachine::BaseRegisterFile::width().

Referenced by tempRegisterFiles().

Here is the call graph for this function:

isConnectedWithBothGuards()

bool MachineConnectivityCheck::isConnectedWithBothGuards ( const TTAMachine::BaseRegisterFile &  sourceRF, const TTAMachine::BaseRegisterFile &  destRF, std::pair< const TTAMachine::RegisterFile *, int >  guardReg  )

static

Checks whether there is a connection from some outport port of a register file or immediate unit into some input port of the given target register file or immediate unit.

Parameters

sourceRF	Source RF/Immediate unit.
destRF	Source RF/Immediate unit.

Returns

True if there is at least one connection from any of the output ports of the source RF/Imm unit into the destination RF.

Definition at line 1949 of file MachineConnectivityCheck.cc.

                                               {
    
    RfRfBoolMap::const_iterator
        i = rfRfCache_.find(RfRfPair(&sourceRF, &destRF));
    if (i != rfRfCache_.end()) {
        if (i->second == false) {
            return false;
        }
    }
    std::set<const TTAMachine::Bus*> srcBuses;
    appendConnectedDestinationBuses(sourceRF, srcBuses);
 
    std::set<const TTAMachine::Bus*> dstBuses;
    appendConnectedSourceBuses(destRF, dstBuses);
 
    std::set<const TTAMachine::Bus*> sharedBuses;
    SetTools::intersection(srcBuses, dstBuses, sharedBuses);
 
    bool trueOK = false;
    bool falseOK = false;
    if (sharedBuses.size() > 0) {
        rfRfCache_[RfRfPair(&sourceRF,&destRF)] = true;
        for (auto bus: sharedBuses) {
            std::pair<bool, bool> guardsOK = hasBothGuards(bus, guardReg);
            trueOK |= guardsOK.first;
            falseOK |= guardsOK.second;
            if (trueOK && falseOK) {
                return true;
            }
        }
    }
    return false;
}

References appendConnectedDestinationBuses(), appendConnectedSourceBuses(), hasBothGuards(), SetTools::intersection(), and rfRfCache_.

Referenced by hasConditionalMoves().

Here is the call graph for this function:

isEquallyConnected()

bool MachineConnectivityCheck::isEquallyConnected ( const TTAMachine::BaseRegisterFile &  RF1, const TTAMachine::BaseRegisterFile &  RF2  )

static

Checks whether the two RFs are connected to the exact same buses.

Definition at line 447 of file MachineConnectivityCheck.cc.

                                           {
 
    std::set<const TTAMachine::Bus*> dstBuses1, dstBuses2;
    appendConnectedDestinationBuses(RF1, dstBuses1);
    appendConnectedDestinationBuses(RF2, dstBuses2);
 
    std::set<const TTAMachine::Bus*> srcBuses1, srcBuses2;
    appendConnectedSourceBuses(RF1, srcBuses1);
    appendConnectedSourceBuses(RF2, srcBuses2);
 
    return dstBuses1 == dstBuses2 && srcBuses1 == srcBuses2;
}

References appendConnectedDestinationBuses(), and appendConnectedSourceBuses().

Referenced by isConnectedToDifferentlyConnectedRFs().

Here is the call graph for this function:

isPortApplicableToWidths()

bool MachineConnectivityCheck::isPortApplicableToWidths ( const TTAMachine::Port &  port, std::set< int >  widths  )

static

Definition at line 463 of file MachineConnectivityCheck.cc.

                                                    {
    auto fup = dynamic_cast<const FUPort*>(&port);
    if (fup == nullptr) {
        return false;
    }
    auto fu = dynamic_cast<const FunctionUnit*>(port.parentUnit());
    if (fu == nullptr) {
        return false;
    }
 
    OperationPool opPool;
 
    for (int i = 0; i < fu->operationCount(); i++) {
        auto hwop = fu->operation(i);
        if (!hwop->isBound(*fup))
            continue;
 
        int opIndex = hwop->io(*fup);
        int oprWidth = operandWidth(*hwop, opIndex);
        if (AssocTools::containsKey(widths, oprWidth)) {
            return true;
        }
    }
    return false;
}

References AssocTools::containsKey(), operandWidth(), OperationPool::operation(), and TTAMachine::Port::parentUnit().

Referenced by fromRfConnected(), needsRegisterCopiesDueImmediateOperands(), and toRfConnected().

Here is the call graph for this function:

maxLIMMCount()

int MachineConnectivityCheck::maxLIMMCount ( const TTAMachine::Machine &  targetMachine )

static

Definition at line 2012 of file MachineConnectivityCheck.cc.

                                            {
    auto iuNav = targetMachine.immediateUnitNavigator();
    int limmCount = 0;
    for (auto iu : iuNav) {
        limmCount += iu->maxReads();
    }
    return limmCount;
}

References TTAMachine::Machine::immediateUnitNavigator().

Referenced by BFOptimization::immCountPreventsScheduling().

Here is the call graph for this function:

maxSIMMCount()

int MachineConnectivityCheck::maxSIMMCount ( const TTAMachine::Machine &  targetMachine )

static

Definition at line 2022 of file MachineConnectivityCheck.cc.

                                            {
 
    auto busNav = targetMachine.busNavigator();
    int simmCount = 0;
    for (auto bus : busNav) {
        if (bus->immediateWidth() > 0) {
            simmCount++;
        }
    }
    return simmCount;
}

References TTAMachine::Machine::busNavigator().

Referenced by BFOptimization::immCountPreventsScheduling().

Here is the call graph for this function:

needRegCopiesDueReadPortConflicts()

std::set< const RegisterFile * > MachineConnectivityCheck::needRegCopiesDueReadPortConflicts ( const TTAMachine::Machine &  machine )

static

Definition at line 904 of file MachineConnectivityCheck.cc.

                                      {
 
    std::map<int, int> noRegInputCount;
    auto fuNav = machine.functionUnitNavigator();
    auto regNav = machine.registerFileNavigator();
 
    std::set<const RegisterFile*> rv;
 
    for (auto fu : fuNav) {
        for (int j = 0; j < fu->operationCount(); j++) {
            auto hwop = fu->operation(j);
            std::map<int, int> myNoRegInputCount;
            for (int k = 1; k <= hwop->operandCount(); k++) {
                auto p = hwop->port(k);
                if (p->inputSocket() != NULL &&
                    (p->noRegister() || p->isTriggering())) {
                    int w = operandWidth(*hwop, k);
                    myNoRegInputCount[w]++;
                    if (w == 1) {
                        myNoRegInputCount[32]++;
                    } else if (w == 32) {
                        myNoRegInputCount[1]++;
                    }
                }
            }
 
            for(auto mw : myNoRegInputCount) {
                int w = mw.first;
                noRegInputCount[w] = std::max(noRegInputCount[w], mw.second);
            }
        }
    }
    for (auto rf: regNav) {
        // one read needed for trigger so <= instead of <
        if (rf->maxReads() < noRegInputCount[rf->width()]) {
            rv.insert(rf);
        }
    }
    return rv;
}

References TTAMachine::Machine::functionUnitNavigator(), machine, operandWidth(), and TTAMachine::Machine::registerFileNavigator().

Referenced by tempRegisterFiles().

Here is the call graph for this function:

needsRegisterCopiesDueImmediateOperands()

bool MachineConnectivityCheck::needsRegisterCopiesDueImmediateOperands ( const TTAMachine::Machine &  mach )

static

Definition at line 947 of file MachineConnectivityCheck.cc.

                                   {
 
    std::set<int> scalarWidths = {1,32};
    for (auto fu: mach.functionUnitNavigator()) {
        for (int j = 0; j < fu->portCount(); j++ ) {
            Port& port = *fu->port(j);
            // connections from RF to FU's
            if (port.inputSocket() != NULL &&
                isPortApplicableToWidths(port, scalarWidths)) {
                if (!canWriteAllImmediates(port)) {
                    return true;
                }
            }
        }
    }
    return false;
}

References canWriteAllImmediates(), TTAMachine::Machine::functionUnitNavigator(), TTAMachine::Port::inputSocket(), and isPortApplicableToWidths().

Referenced by tempRegisterFiles().

Here is the call graph for this function:

operandWidth()

int MachineConnectivityCheck::operandWidth ( const TTAMachine::HWOperation &  hwop, int  index  )

static

Definition at line 890 of file MachineConnectivityCheck.cc.

                                                  {
    OperationPool opPool;
    Operation& op = opPool.operation(hwop.name().c_str());
    if (&op == &NullOperation::instance()) {
        TCEString msg = "ADF has unknown operation: "; msg << hwop.name();
        throw Exception(__FILE__, __LINE__, __func__, msg);
    }
    Operand& operand = op.operand(index);
    return operand.width();
}

References __func__, NullOperation::instance(), TTAMachine::HWOperation::name(), Operation::operand(), OperationPool::operation(), and Operand::width().

Referenced by isPortApplicableToWidths(), and needRegCopiesDueReadPortConflicts().

Here is the call graph for this function:

raConnected()

bool MachineConnectivityCheck::raConnected ( const TTAMachine::Machine &  machine )

static

Definition at line 966 of file MachineConnectivityCheck.cc.

                                                                           {
 
    static bool spammed = false;
    // check connection from RA to jump for fn return.
    ControlUnit& cu = *machine.controlUnit();
 
    if (cu.returnAddressPort() == nullptr) return true;
 
    SpecialRegisterPort& ra = *cu.returnAddressPort();
    if (cu.hasOperation("jump")) {
        auto jumpOp = cu.operation("jump");
        auto port = jumpOp->port(1);
        if (!isConnected(ra, *port)) {
            if (Application::verboseLevel() > 0 && !spammed) {
                std::cout << "Reserving registers for temp reg use because "
                          << "a connection is missing between the RA port "
                          << "and the address port of jump operation." << std::endl;
                spammed = true;
            }
            return false;
        }
    }
 
    // check that RA can be loaded and stored
    TCEString ldOp = machine.isLittleEndian() ? "LD32" : "LDW";
    TCEString stOp = machine.isLittleEndian() ? "ST32" : "STW";
    bool hasLoad = false;
    bool hasStore = false;
    bool raConnectedToLoad = false;
    bool raConnectedToStore = false;
    for (auto fu: machine.functionUnitNavigator()) {
        if (!fu->hasAddressSpace() ||
            !fu->addressSpace()->hasNumericalId(0)) {
            continue;
        }
        if (fu->hasOperation(ldOp)) {
            hasLoad = true;
            auto ldhwop = fu->operation(ldOp);
            auto port = ldhwop->port(2);
            if (isConnected(*port, ra)) {
                raConnectedToLoad = true;
            }
        }
 
        if (fu->hasOperation(stOp)) {
            hasStore = true;
            auto sthwop = fu->operation(stOp);
            auto port = sthwop->port(2);
            if (isConnected(ra, *port)) {
                raConnectedToStore = true;
            }
        }
    }
 
    if ((raConnectedToLoad || !hasLoad) &&
        (raConnectedToStore || !hasStore)) {
        return true;
    } else {
        if (Application::verboseLevel() > 0 && !spammed) {
            std::cout << "Reserving registers for temp reg use because "
                      << "a connection is missing between the RA port "
                      << "and the LSU." << std::endl;
            spammed = true;
        }
        return false;
    }
}

References TTAMachine::Machine::controlUnit(), TTAMachine::Machine::functionUnitNavigator(), TTAMachine::FunctionUnit::hasOperation(), isConnected(), TTAMachine::Machine::isLittleEndian(), machine, TTAMachine::FunctionUnit::operation(), TTAMachine::HWOperation::port(), TTAMachine::ControlUnit::returnAddressPort(), and Application::verboseLevel().

Referenced by tempRegisterFiles().

Here is the call graph for this function:

requiredImmediateWidth()

int MachineConnectivityCheck::requiredImmediateWidth ( bool  signExtension, const TTAProgram::TerminalImmediate &  source, const TTAMachine::Machine &  mach  )

static

Returns the bit width the immediate requires.

Parameters

signExtension	Whether sign extension is used.
source	The immediate terminal.

Returns

Bitwidth required for the immediate.

Definition at line 1250 of file MachineConnectivityCheck.cc.

                                   {
 
    if (source.isCodeSymbolReference()) {
        const AddressSpace& instrAS = *mach.controlUnit()->addressSpace();
        if (source.toString() == "_end") {
            AddressSpace* dataAS;
            try {
                dataAS = MachineInfo::defaultDataAddressSpace(mach);
            } catch (Exception&) {
                assert(false && "No default data address space");
            }
 
            return signExtension ?
                MathTools::requiredBitsSigned(dataAS->end()):
                MathTools::requiredBits(dataAS->end());
        } else {
            return signExtension ?
                MathTools::requiredBitsSigned (instrAS.end()):
                MathTools::requiredBits(instrAS.end());
        }
    }
    if (source.isInstructionAddress() || source.isBasicBlockReference()) {
        const AddressSpace& as = *mach.controlUnit()->addressSpace();
        return signExtension ? 
            MathTools::requiredBitsSigned(as.end()): 
            MathTools::requiredBits(as.end());
    }
 
    int bits = -1;
    if (signExtension) {
        bits =
            MathTools::requiredBitsSigned(source.value().sLongWordValue());
    } else if (!signExtension) {
        bits =
            MathTools::requiredBits(source.value().uLongWordValue());
    } 
 
    return bits;
}

References TTAMachine::FunctionUnit::addressSpace(), assert, TTAMachine::Machine::controlUnit(), MachineInfo::defaultDataAddressSpace(), TTAMachine::AddressSpace::end(), TTAProgram::Terminal::isBasicBlockReference(), TTAProgram::Terminal::isCodeSymbolReference(), TTAProgram::Terminal::isInstructionAddress(), MathTools::requiredBits(), MathTools::requiredBitsSigned(), SimValue::sLongWordValue(), TTAProgram::TerminalImmediate::toString(), SimValue::uLongWordValue(), and TTAProgram::TerminalImmediate::value().

Referenced by RegisterCopyAdder::addConnectionRegisterCopiesImmediate(), IUResource::canAssign(), BusBroker::canTransportImmediate(), canTransportImmediate(), canTransportImmediate(), and findPossibleSourcePorts().

Here is the call graph for this function:

rfConnected()

bool MachineConnectivityCheck::rfConnected ( const TTAMachine::RegisterFile &  rf )

static

Checks if an RF is connected to all other units

It this returns true, then this FU can be used as the only register file to be used for reduced connectivity-register copying.

Parameters

rf	Register file to be checked.

Returns

Returns true if the given RF is connected to all ports in all FU's and at least to some output port in all immediate units.

Definition at line 587 of file MachineConnectivityCheck.cc.

                                      {
 
    return fromRfConnected(rf) && toRfConnected(rf);
}

References fromRfConnected(), and toRfConnected().

Referenced by tempRegisterFiles().

Here is the call graph for this function:

shortImmBits() [1/2]

static std::pair< int, int > MachineConnectivityCheck::shortImmBits ( std::set< const TTAMachine::Bus * > &  buses )

static

Referenced by immBits(), and immBits().

shortImmBits() [2/2]

void MachineConnectivityCheck::shortImmBits ( std::set< const TTAMachine::Bus * > &  buses, std::pair< int, int > &  immBits  )

static

Definition at line 606 of file MachineConnectivityCheck.cc.

                                                                     {
 
    for (auto b: buses) {
        int w = b->immediateWidth();
        if (b->signExtends()) {
            immBits.first = std::max(immBits.first, w);
        } else {
            immBits.second = std::max(immBits.second,w);
        }
    }
}

References immBits().

Here is the call graph for this function:

tempRegisterFiles()

std::set< const RegisterFile *, MachinePart::Comparator > MachineConnectivityCheck::tempRegisterFiles ( const TTAMachine::Machine &  machine )

static

Gets all register files needed for limited connectivity temp registers

Parameters

machine

machine we are checking

Returns

vector of registerfiles whose last register is to be used for

Definition at line 1041 of file MachineConnectivityCheck.cc.

                                      {
    static bool spammed = false;
 
    std::set<const RegisterFile*, TTAMachine::MachinePart::Comparator> rfs;
 
    auto regNav = machine.registerFileNavigator();
    auto iuNav = machine.immediateUnitNavigator();
    auto fuNav = machine.functionUnitNavigator();
 
    auto reducedConnRfs = needRegCopiesDueReadPortConflicts(machine);
    std::set<int> portConflictWidths;
    for (auto rf: reducedConnRfs) {
        int w = rf->width();
        portConflictWidths.insert(w);
    }
 
    bool portConflicts = !reducedConnRfs.empty();
    bool allConnected = true;
    if (portConflicts) {
        if (Application::verboseLevel() > 0 && !spammed) {
            std::cout << "Reserving registers for temp reg use because " <<
                "of possible RF port conflicts; There are operations " <<
                "on registerless FUs with more operations than there are " <<
                "read ports on some RFs." << std::endl;
            spammed = true;
        }
        allConnected = false;
    }
    int widestRFWidth = 0;
 
    std::set<int> lackingConnectivityWidths;
    std::set<const TTAMachine::RegisterFile*> allConnectedRFs;
    std::map<int, const RegisterFile*> priorityConnectedRFs;
    std::map<int, int> regCounts;
    std::map<int, int> regFileCounts;
 
    // may need temp reg copies because immediate operands cannto be
    // transferred to all operations directly.
    if (allConnected && needsRegisterCopiesDueImmediateOperands(machine)) {
        lackingConnectivityWidths.insert(32);
        allConnected = false;
        if (Application::verboseLevel() > 0 && !spammed) {
            std::cout << "Reserving registers for temp reg use because " <<
                "all immediate operands are not possible to transfer " <<
                "directly. This reduces the number of registers available " <<
                "for storing usable values." << std::endl;
            spammed = true;
        }
    }
 
    for (auto rf: regNav) {
        int w = rf->width();
        if (w > widestRFWidth) {
            widestRFWidth = w;
        }
        regCounts[w] += rf->size();
        regFileCounts[w]++;
    }
 
    for (auto rf: regNav) {
        int width = rf->width();
        if (!rfConnected(*rf)) {
            reducedConnRfs.insert(rf);
            allConnected = false;
            lackingConnectivityWidths.insert(width);
            if (Application::verboseLevel() > 0 && !spammed) {
                std::cout << "Reserving registers for temp reg use because RF: "
                          << rf->name() << " has reduced connectivity to FUs or "
                          << "immediates." << std::endl;
                spammed = true;
            }
        } else {
            allConnectedRFs.insert(rf);
            // we have at least on RF connected to everywhere so use it.
            // but only if it's wide enough (as wide as the widest RF)
            auto connectedRF = priorityConnectedRFs[width];
 
            // ra/imm/narrowed connectivity for 32bit
            if ((width <= 32 || isConnectedToDifferentlyConnectedRFs(*rf)) &&
                 (connectedRF == nullptr ||
                rf->maxReads() * rf->maxWrites() >
                  connectedRF->maxReads() * connectedRF->maxWrites())) {
                priorityConnectedRFs[width] = rf;
            }
        }
    }
 
    if (!raConnected(machine)) {
        allConnected = false;
        lackingConnectivityWidths.insert(32);
    }
 
    if (allConnected) {
        return rfs;
    }
 
    bool needNextBigger = false;
    if (AssocTools::containsKey(lackingConnectivityWidths, 1)) {
        if (priorityConnectedRFs[1] != nullptr &&
            regCounts[1] > 2 &&
            regFileCounts[1] > 1) {
            rfs.insert(priorityConnectedRFs[1]);
        } else {
            needNextBigger = true;
        }
    }
    // 32-bit.
    if (needNextBigger ||
        AssocTools::containsKey(lackingConnectivityWidths, 32) ||
        portConflicts) {
        if (!portConflicts && priorityConnectedRFs[32] != nullptr) {
            rfs.insert(priorityConnectedRFs[32]);
        } else {
            for (auto rf: regNav) {
                if (rf->width() == 32 &&
                    (isConnectedToDifferentlyConnectedRFs(*rf) ||
                     portConflicts)) {
                    rfs.insert(rf);
                }
            }
        }
    }
 
    // vector.
    for (int w = 64; w <= widestRFWidth; w*=2) {
        if (AssocTools::containsKey(lackingConnectivityWidths, w) ||
            portConflicts) {
            if (!portConflicts && priorityConnectedRFs[w] != nullptr) {
                rfs.insert(priorityConnectedRFs[w]);
            } else {
                for (auto rf: regNav) {
                    if (rf->width() == w &&
                        (isConnectedToDifferentlyConnectedRFs(*rf) ||
                         portConflicts)) {
                        rfs.insert(rf);
                    }
                }
            }
        }
    }
    
    return rfs;
}

References AssocTools::containsKey(), TTAMachine::Machine::functionUnitNavigator(), TTAMachine::Machine::immediateUnitNavigator(), isConnectedToDifferentlyConnectedRFs(), machine, needRegCopiesDueReadPortConflicts(), needsRegisterCopiesDueImmediateOperands(), raConnected(), TTAMachine::Machine::registerFileNavigator(), rfConnected(), and Application::verboseLevel().

Referenced by RegisterCopyAdder::findTempRegisters(), BBSchedulerController::handleBasicBlock(), RegisterRenamer::initialize(), ScheduleEstimator::maximumSizeOfBB(), and TDGen::TDGen().

Here is the call graph for this function:

toRfConnected()

bool MachineConnectivityCheck::toRfConnected ( const TTAMachine::RegisterFile &  rf )

static

Checks whether there is a connection to the given Register file from all FU's and control unit of the machine.

It both this and fromRfConnected() returns true, then this FU can be used as the only register file to be used for reduced connectivity-register copying.

Parameters

brf	Register file or immediate unit being checked.

Returns

true if this RF can write to all ports af all FU's.

Definition at line 674 of file MachineConnectivityCheck.cc.

                                      {
 
    int width = rf.width();
    bool isVectorRF = width > 32;
    TTAMachine::Machine& mach = *rf.machine();
    TTAMachine::Machine::FunctionUnitNavigator fuNav = 
        mach.functionUnitNavigator();
    TTAMachine::Machine::ImmediateUnitNavigator iuNav = 
        mach.immediateUnitNavigator();
 
    std::set<const TTAMachine::Bus*> rfBuses;
 
    std::set<int> widths;
    widths.insert(rf.width());
    if (width == 32) {
        widths.insert(1);
        widths.insert(16); // Needed for half-floats?
 
    }
    if (width == 1) {
        widths.insert(32);
    }
 
    for (int i = 0; i < rf.portCount(); i++) {
        const TTAMachine::Port& port = *rf.port(i);
        if (port.inputSocket() != NULL) {
            appendConnectedSourceBuses(port, rfBuses);
        }
    }
 
    // check connections from function units
    for (auto fu: fuNav) {
        for (int j = 0; j < fu->portCount(); j++ ) {
            Port& port = *fu->port(j);
            // connections from FU to RF
            if (port.outputSocket() != NULL &&
                isPortApplicableToWidths(port, widths) &&
                port.width() >= width) {
                std::set<const TTAMachine::Bus*> sharedBuses;
                SetTools::intersection(
                    rfBuses, connectedDestinationBuses(port), sharedBuses);
                if (sharedBuses.size() == 0) {
                    return false;
                }
            }
        }
    } 
 
    // no need to check for imms or cu connections for vector RFs
    if (isVectorRF) {
        return true;
    }
 
    // check connections from control unit
    TTAMachine::ControlUnit& cu = *mach.controlUnit();
    for (int i = 0; i < cu.portCount(); i++ ) {
        Port& port = *cu.port(i);
 
        // connections from CU to RF
        if (port.width() == width) {
            if (port.outputSocket() != NULL) {
                std::set<const TTAMachine::Bus*> sharedBuses;
                SetTools::intersection(
                    rfBuses, connectedDestinationBuses(port), sharedBuses);
                if (sharedBuses.size() == 0) {
                    return false;
                }
            }
        }
    }
 
    // if all immediates can be written to the RF?
    auto rfImmBits = immBits(rf);
    if (rfImmBits.first >= width || rfImmBits.second >= width) {
        return true;
    }
 
    // if there are wider imms in the adf, not ok
    auto allImmBits = immBits(*rf.machine());
    if (rfImmBits.first < allImmBits.first ||
        (rfImmBits.second < allImmBits.second &&
         (rfImmBits.first-1) < allImmBits.second)) {
        return false;
    }
    return true;
}

References appendConnectedSourceBuses(), connectedDestinationBuses(), TTAMachine::Machine::controlUnit(), TTAMachine::Machine::functionUnitNavigator(), immBits(), TTAMachine::Machine::immediateUnitNavigator(), TTAMachine::Port::inputSocket(), SetTools::intersection(), isPortApplicableToWidths(), TTAMachine::Component::machine(), TTAMachine::Port::outputSocket(), TTAMachine::BaseRegisterFile::port(), TTAMachine::FunctionUnit::port(), TTAMachine::Unit::portCount(), TTAMachine::BaseRegisterFile::width(), and TTAMachine::Port::width().

Referenced by rfConnected().

Here is the call graph for this function:

totalConnectionCount()

int MachineConnectivityCheck::totalConnectionCount ( const TTAMachine::Machine &  mach )

static

Definition at line 1464 of file MachineConnectivityCheck.cc.

                                   {
    int totalFound = 0;
    for (int bi = 0; bi < mach.busNavigator().count(); ++bi) {
        const TTAMachine::Segment& s = 
            *mach.busNavigator().item(bi)->segment(0);
        totalFound += s.connectionCount();
    }
    return totalFound;
}

References TTAMachine::Machine::busNavigator(), TTAMachine::Segment::connectionCount(), and TTAMachine::Machine::Navigator< ComponentType >::item().

Referenced by DSDBManager::addArchitecture(), ConnectionSweeper::explore(), ConnectionSweeper::removeAllConnections(), and ConnectionSweeper::removeLeastNecessaryConnections().

Here is the call graph for this function:

Member Data Documentation

portPortCache_

MachineConnectivityCheck::PortPortBoolMap MachineConnectivityCheck::portPortCache_

staticprivate

Definition at line 319 of file MachineConnectivityCheck.hh.

Referenced by isConnected().

portRfCache_

MachineConnectivityCheck::PortRfBoolMap MachineConnectivityCheck::portRfCache_

staticprivate

Definition at line 322 of file MachineConnectivityCheck.hh.

Referenced by isConnected().

rfPortCache_

MachineConnectivityCheck::RfPortBoolMap MachineConnectivityCheck::rfPortCache_

staticprivate

Definition at line 321 of file MachineConnectivityCheck.hh.

Referenced by isConnected().

rfRfCache_

MachineConnectivityCheck::RfRfBoolMap MachineConnectivityCheck::rfRfCache_

staticprivate

Definition at line 320 of file MachineConnectivityCheck.hh.

Referenced by isConnected(), and isConnectedWithBothGuards().

---

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

• MachineConnectivityCheck.hh
• MachineConnectivityCheck.cc