#include <InputFUBroker.hh>

Inheritance diagram for InputFUBroker:

Collaboration diagram for InputFUBroker:

Public Member Functions
	InputFUBroker (std::string, unsigned int initiationInterval=0)

virtual	~InputFUBroker ()

virtual SchedulingResourceSet	allAvailableResources (int cycle, const MoveNode &node, const TTAMachine::Bus bus, const TTAMachine::FunctionUnit srcFU, const TTAMachine::FunctionUnit dstFU, int immWriteCycle, const TTAMachine::ImmediateUnit immu, int immRegIndex) const override

virtual int	earliestCycle (int cycle, const MoveNode &node, const TTAMachine::Bus bus, const TTAMachine::FunctionUnit srcFU, const TTAMachine::FunctionUnit dstFU, int immWriteCycle, const TTAMachine::ImmediateUnit immu, int immRegIndex) const override

virtual int	latestCycle (int cycle, const MoveNode &node, const TTAMachine::Bus bus, const TTAMachine::FunctionUnit srcFU, const TTAMachine::FunctionUnit dstFU, int immWriteCycle, const TTAMachine::ImmediateUnit immu, int immRegIndex) const override

virtual bool	isAlreadyAssigned (int cycle, const MoveNode &node, const TTAMachine::Bus *preassignedBus) const override

virtual bool	isApplicable (const MoveNode &node, const TTAMachine::Bus *preAssigndBus=0) const override

virtual void	assign (int cycle, MoveNode &node, SchedulingResource &res, int immWriteCycle, int immRegIndex) override

virtual void	unassign (MoveNode &node) override

virtual void	buildResources (const TTAMachine::Machine &target) override

virtual void	setupResourceLinks (const ResourceMapper &mapper) override

Public Member Functions inherited from FUBroker
	FUBroker (std::string name, unsigned int initiationInterval=0)

virtual	~FUBroker ()

Public Member Functions inherited from ResourceBroker
	ResourceBroker (std::string, unsigned int initiationInterval=0)

virtual	~ResourceBroker ()

virtual bool	isAnyResourceAvailable (int cycle, const MoveNode &node, const TTAMachine::Bus bus, const TTAMachine::FunctionUnit srcFU, const TTAMachine::FunctionUnit dstFU, int immWriteCycle, const TTAMachine::ImmediateUnit immu, int immRegIndex) const

virtual SchedulingResource &	availableResource (int cycle, const MoveNode &node, const TTAMachine::Bus bus, const TTAMachine::FunctionUnit srcFU, const TTAMachine::FunctionUnit dstFU, int immWriteCycle, const TTAMachine::ImmediateUnit immu, int immRegIndex) const

virtual bool	isAvailable (SchedulingResource &des, const MoveNode &node, int cycle, const TTAMachine::Bus bus, const TTAMachine::FunctionUnit srcFU, const TTAMachine::FunctionUnit dstFU, int immWriteCycle, const TTAMachine::ImmediateUnit immu, int immRegIndex) const

SchedulingResource *	resourceOf (const TTAMachine::MachinePart &mp) const

virtual const TTAMachine::MachinePart &	machinePartOf (const SchedulingResource &r) const

bool	hasResourceOf (const TTAMachine::MachinePart &mp) const

bool	hasResource (const SchedulingResource &r) const

int	resourceCount () const

virtual bool	isBusBroker () const

virtual bool	isITemplateBroker () const

virtual bool	isIUBroker () const

virtual bool	isExecutionPipelineBroker () const

void	validateResources () const

virtual std::string	brokerName () const

void	resources (ResourceSet &contents)

virtual void	setInitiationInterval (unsigned int cycles)

virtual void	clear ()

virtual void	setMaxCycle (unsigned int)

Additional Inherited Members
Public Types inherited from ResourceBroker
typedef std::set< SchedulingResource * >	ResourceSet

Protected Types inherited from ResourceBroker
typedef std::map< const TTAMachine::MachinePart , SchedulingResource , TTAMachine::MachinePart::Comparator >	ResourceMap

typedef std::map< const MoveNode , SchedulingResource , MoveNode::Comparator >	MoveResMap

Protected Member Functions inherited from FUBroker
std::pair< bool, const TTAMachine::FunctionUnit * >	findDstFUOfMove (const MoveNode &node, const TTAMachine::FunctionUnit *resFU, DataDependenceGraph::NodeSet &processedInputNodes) const

std::pair< bool, const TTAMachine::FunctionUnit * >	findFUOfPO (ProgramOperation &po, const TTAMachine::FunctionUnit *resFU) const

Protected Member Functions inherited from ResourceBroker
void	setResourceMapper (const ResourceMapper &mapper)

const ResourceMapper &	resourceMapper () const

unsigned int	instructionIndex (unsigned int) const

void	addResource (const TTAMachine::MachinePart &mp, SchedulingResource *res)

Protected Attributes inherited from ResourceBroker
unsigned int	initiationInterval_

ResourceMap	resMap_

const ResourceMapper *	resourceMapper_

MoveResMap	assignedResources_

std::string	brokerName_

Detailed Description

Input function unit broker.

Definition at line 55 of file InputFUBroker.hh.

Constructor & Destructor Documentation

◆ InputFUBroker()

InputFUBroker::InputFUBroker	(	std::string	name,
		unsigned int	initiationInterval = `0`
	)

Constructor.

Definition at line 68 of file InputFUBroker.cc.

                                        :
    FUBroker(name, initiationInterval) {
}

◆ ~InputFUBroker()

InputFUBroker::~InputFUBroker ( )

virtual

Destructor.

Definition at line 76 of file InputFUBroker.cc.

76 {

77}

Member Function Documentation

◆ allAvailableResources()

SchedulingResourceSet InputFUBroker::allAvailableResources	(	int	cycle,
		const MoveNode &	node,
		const TTAMachine::Bus *	bus,
		const TTAMachine::FunctionUnit *	srcFU,
		const TTAMachine::FunctionUnit *	dstFU,
		int	immWriteCycle,
		const TTAMachine::ImmediateUnit *	immu,
		int	immRegIndex
	)		const

overridevirtual

Return all resources managed by this broker that can be assigned to the given node in the given cycle.

Parameters

cycle	Cycle.
node	Node.

Returns: All resources managed by this broker that can be assigned to the given node in the given cycle.

Reimplemented from ResourceBroker.

Definition at line 89 of file InputFUBroker.cc.

                                                {
    if (!isApplicable(node)) {
        string msg = "Broker not capable of assigning resources to node!";
        throw ModuleRunTimeError(__FILE__, __LINE__, __func__, msg);
    }
 
    Move& move = const_cast<MoveNode&>(node).move();
    TerminalFUPort& dst = static_cast<TerminalFUPort&>(move.destination());
 
    SchedulingResourceSet resourceSet;
    ResourceMap::const_iterator resIter = resMap_.begin();
 
    if (dynamic_cast<const SpecialRegisterPort*>(&dst.port()) != NULL) {
        // only gcu applies
        while (resIter != resMap_.end()) {
            const ControlUnit* gcu =
                dynamic_cast<const ControlUnit*>((*resIter).first);
            if (gcu != NULL) {
                InputFUResource* fuRes =
                    static_cast<InputFUResource*>((*resIter).second);
                if (fuRes->isAvailable(cycle)) {
                    resourceSet.insert(*fuRes);
                }
                return resourceSet;
            }
            resIter++;
        }
        abortWithError("No GCU found!");
    }
 
    int opIndex = dst.operationIndex();
    Operation& op = dst.hintOperation();
    std::string opName = StringTools::stringToLower(op.name());
 
    // check if a unit has already been assigned to some node
    // of the same operation and use it.
    const FunctionUnit* foundFU = dstFU;
 
    DataDependenceGraph::NodeSet processedInputNodes;
    auto a = findDstFUOfMove(node, foundFU, processedInputNodes);
    if (a.first) {
        foundFU = a.second;
    } else { // conflicting FUs, cannot schedule
        if (foundFU != nullptr) {
            return SchedulingResourceSet();
        }
    }
 
    if (foundFU) {
        InputFUResource& foundFURes =
            static_cast<InputFUResource&>(*resourceOf(*foundFU));
 
        // Find what is the port on a new FU for given
        // operation index. Find a socket for testing.
        HWOperation* hwOp = foundFU->operationLowercase(opName);
        Socket* soc = hwOp->port(opIndex)->inputSocket();
 
        FUPort* tempPort =
            dynamic_cast<FUPort*>(hwOp->port(opIndex));
        if (tempPort == NULL){
            throw InvalidData(
                __FILE__, __LINE__, __func__,
                "Target is missing necessary FUPort!");
        }
        bool triggering = false;
        if (tempPort->isTriggering()) {
            triggering = true;
        }
 
        InputPSocketResource* pSocket = NULL;
        try {
            pSocket = &static_cast<InputPSocketResource&>(
                resourceMapper().resourceOf(*soc));
        } catch (const KeyNotFound& e) {
            std::string msg = "InputFUBroker: finding ";
            msg += " resource for Socket ";
            msg += " failed with error: ";
            msg += e.errorMessageStack();
            throw KeyNotFound(
                __FILE__, __LINE__, __func__, msg);
        }
        if (foundFURes.canAssign(
                cycle, node, *pSocket, triggering)) {
            resourceSet.insert(foundFURes);
        }
        return resourceSet;
    }
 
    std::set<TCEString> candidateFUs;
    std::set<TCEString> allowedFUs;
    std::set<TCEString> rejectedFUs;
    // not all nodes have dest operation info set as the RM can be called
    // for single moves 
    if (node.isDestinationOperation()) {
        // check if the move or other moves in the same program operation have 
        // candidate FUs set which limits the choice of FU for the node
        ProgramOperation& destOp = node.destinationOperation();
        for (int in = 0; in < destOp.inputMoveCount(); ++in) {
            MoveNode& n = destOp.inputMove(in);
            MachineConnectivityCheck::addAnnotatedFUs(
                candidateFUs, n.move(),
                TTAProgram::ProgramAnnotation::ANN_CONN_CANDIDATE_UNIT_DST);
            MachineConnectivityCheck::addAnnotatedFUs(
                allowedFUs, n.move(),
                TTAProgram::ProgramAnnotation::ANN_ALLOWED_UNIT_DST);
            MachineConnectivityCheck::addAnnotatedFUs(
                rejectedFUs, n.move(),
                TTAProgram::ProgramAnnotation::ANN_REJECTED_UNIT_DST);
        }
    }
    
    // if the move has already the FU assigned, force it to be chosen
    // kludge implementation that use the candidate set code
    const TTAMachine::FunctionUnit& targetFU =
        node.move().destination().functionUnit();
    if (dynamic_cast<const UniversalFunctionUnit*>(&targetFU) == NULL &&
        dynamic_cast<const TTAMachine::ControlUnit*>(&targetFU) == NULL)  {
        candidateFUs.clear();
        candidateFUs.insert(node.move().destination().functionUnit().name());
        debugLogRM(
            TCEString("Added candidate FU duo pre-set fu") +
            node.move().destination().functionUnit().name());
    }
 
    // find units that support operation and are available
    while (resIter != resMap_.end()) {
        const FunctionUnit* unit =
            static_cast<const FunctionUnit*>((*resIter).first);
 
        assert(unit != NULL);
        // in case the unit is limited by a candidate set, skip FUs that are
        // not in it
        debugLogRM(TCEString("checking ") << unit->name());
        if (candidateFUs.size() > 0 &&
            !AssocTools::containsKey(candidateFUs, unit->name())) {
            debugLogRM(
                TCEString("skipped ") << unit->name() << " because it was not "
                " in the candidate set.");
            ++resIter;
            continue;
        }
 
        if (allowedFUs.size() > 0 &&
            !AssocTools::containsKey(allowedFUs, unit->name())) {
            debugLogRM(
                TCEString("skipped ") << unit->name() << " because it was not "
                " in the allowed set.");
            ++resIter;
            continue;
        }
 
        if (AssocTools::containsKey(rejectedFUs, unit->name())) {
            debugLogRM(
                TCEString("skipped ") << unit->name() << " because it was"
                " in the rejected set.");
            ++resIter;
            continue;
        }
 
        debugLogRM(TCEString("Found ") + unit->name());
 
        const SchedulingResource& res = *resourceOf(*unit);
        if (res.isInputFUResource()) {
            const InputFUResource& fuRes =
                static_cast<InputFUResource&>(*resourceOf(*unit));
            if (unit->hasOperationLowercase(opName)) {
                debugLogRM(TCEString("found FU with the op ") + opName);
                HWOperation* hwOp = unit->operationLowercase(opName);
                assert(hwOp != NULL);                
                Socket* soc = hwOp->port(opIndex)->inputSocket();
 
                FUPort* tempPort =
                    dynamic_cast<FUPort*>(hwOp->port(opIndex));
                if (tempPort == NULL){
                    throw InvalidData(
                        __FILE__, __LINE__, __func__, 
                        "Target is missing necessary FUPort!");                               
                }
                bool triggering = false;
                if (tempPort->isTriggering()) {
                    triggering = true;
                }
 
                InputPSocketResource* pSocket = NULL;
                try {
                    pSocket = &static_cast<InputPSocketResource&>(
                        resourceMapper().resourceOf(*soc));
                } catch (const KeyNotFound& e) {
                    std::string msg = "InputFUBroker: finding ";
                    msg += " resource for Socket ";
                    msg += " failed with error: ";
                    msg += e.errorMessageStack();
                    throw KeyNotFound(
                        __FILE__, __LINE__, __func__, msg);
                }                                                            
                if (fuRes.canAssign(cycle, node, *pSocket, triggering)) {
                    resourceSet.insert(*(*resIter).second);
                } else {
                    debugLogRM("could not assign the fuRes to it.");
                }
            } else {
                debugLogRM(TCEString("does not have operation ") + opName);
            }
        }
        resIter++;
    }
    if (resourceSet.count() == 0) {
        debugLogRM("InputFUBroker returned an empty resource set.");
    }
 
    return resourceSet;
}

References __func__, abortWithError, MachineConnectivityCheck::addAnnotatedFUs(), TTAProgram::ProgramAnnotation::ANN_ALLOWED_UNIT_DST, TTAProgram::ProgramAnnotation::ANN_CONN_CANDIDATE_UNIT_DST, TTAProgram::ProgramAnnotation::ANN_REJECTED_UNIT_DST, assert, InputFUResource::canAssign(), AssocTools::containsKey(), SchedulingResourceSet::count(), debugLogRM, TTAProgram::Move::destination(), MoveNode::destinationOperation(), Exception::errorMessageStack(), FUBroker::findDstFUOfMove(), TTAProgram::Terminal::functionUnit(), TTAMachine::FunctionUnit::hasOperationLowercase(), TTAProgram::TerminalFUPort::hintOperation(), ProgramOperation::inputMove(), ProgramOperation::inputMoveCount(), TTAMachine::Port::inputSocket(), SchedulingResourceSet::insert(), isApplicable(), InputFUResource::isAvailable(), MoveNode::isDestinationOperation(), SchedulingResource::isInputFUResource(), TTAMachine::FUPort::isTriggering(), MoveNode::move(), TTAMachine::Component::name(), Operation::name(), TTAProgram::TerminalFUPort::operationIndex(), TTAMachine::FunctionUnit::operationLowercase(), TTAProgram::TerminalFUPort::port(), TTAMachine::HWOperation::port(), ResourceBroker::resMap_, ResourceBroker::resourceMapper(), ResourceBroker::resourceOf(), ResourceMapper::resourceOf(), and StringTools::stringToLower().

Here is the call graph for this function:

◆ assign()

void InputFUBroker::assign	(	int	cycle,
		MoveNode &	node,
		SchedulingResource &	res,
		int	immWriteCycle,
		int	immRegIndex
	)

overridevirtual

Mark given resource as in use for the given node, and assign the corresponding machine part (if applicable) to the node's move.

If the node is already assigned to given resource, this method does nothing.

Parameters

cycle	Cycle.
node	Node to assign.
res	Resource representing Input of and FU

Exceptions

WrongSubclass	If this broker does not recognise the given type of resource.
InvalidParameters	If he given resource cannot be assigned to given node or no corresponding machine part is found.

Implements ResourceBroker.

Definition at line 414 of file InputFUBroker.cc.

                                                                  {
    if (!isApplicable(node)) {
        string msg = "Broker not capable of assigning resources to node!";
        throw WrongSubclass(__FILE__, __LINE__, __func__, msg);
    }
 
    if (!hasResource(res)) {
        string msg = "Broker does not contain given resource.";
        throw InvalidData(__FILE__, __LINE__, __func__, msg);
    }
 
    InputFUResource& fuRes = static_cast<InputFUResource&>(res);
 
    Move& move = const_cast<MoveNode&>(node).move();
    TerminalFUPort& dst = static_cast<TerminalFUPort&>(move.destination());
 
    if (dynamic_cast<const SpecialRegisterPort*>(&dst.port()) != NULL) {
 
        const ControlUnit* gcu =
            dynamic_cast<const ControlUnit*>(&machinePartOf(fuRes));
 
        if (gcu != NULL) {
            TerminalFUPort* newDst =
                new TerminalFUPort(*gcu->returnAddressPort());
            move.setDestination(newDst);
            fuRes.assign(cycle, node);
            assignedResources_.insert(
                std::pair<const MoveNode*, SchedulingResource*>(
                     &node,&fuRes));
            return;
        } else {
            abortWithError("GCU required but tried to assign something else!");
        }
    }
 
    int opIndex = dst.operationIndex();
    Operation& op = dst.hintOperation();
 
    const FunctionUnit& unit =
        static_cast<const FunctionUnit&>(machinePartOf(fuRes));
    HWOperation* hwOp = unit.operation(op.name());
    TerminalFUPort* newDst = new TerminalFUPort(*hwOp, opIndex);
    newDst->setProgramOperation(dst.programOperation());
    move.setDestination(newDst);
    fuRes.assign(cycle, node);
    assignedResources_.insert(
        std::pair<const MoveNode*, SchedulingResource*>(&node, &fuRes));
}

References __func__, abortWithError, InputFUResource::assign(), ResourceBroker::assignedResources_, TTAProgram::Move::destination(), ResourceBroker::hasResource(), TTAProgram::TerminalFUPort::hintOperation(), isApplicable(), ResourceBroker::machinePartOf(), Operation::name(), TTAMachine::FunctionUnit::operation(), TTAProgram::TerminalFUPort::operationIndex(), TTAProgram::TerminalFUPort::port(), TTAProgram::TerminalFUPort::programOperation(), TTAMachine::ControlUnit::returnAddressPort(), TTAProgram::Move::setDestination(), and TTAProgram::TerminalFUPort::setProgramOperation().

Here is the call graph for this function:

◆ buildResources()

void InputFUBroker::buildResources ( const TTAMachine::Machine & target )

overridevirtual

Build all resource objects of the controlled type required to model scheduling resources of the given target processor.

This method cannot set up the resource links (dependent and related resources) of the constructed resource objects.

Parameters

target Target machine.

Implements ResourceBroker.

Definition at line 503 of file InputFUBroker.cc.

                                                             {
 
    std::map<const TTAMachine::FunctionUnit*,int> nopWeights;
 
    Machine::FunctionUnitNavigator navi = target.functionUnitNavigator();
    for (int i = 0; i < navi.count(); i++) {
        FunctionUnit* fu = navi.item(i);
        InputFUResource* fuResource = new InputFUResource(
            fu->name(), fu->operationCount(), nopWeights[fu],
            initiationInterval_);
        ResourceBroker::addResource(*fu, fuResource);
    }
 
    ControlUnit* gcu = target.controlUnit();
    InputFUResource* fuResource = new InputFUResource(
        gcu->name(), gcu->operationCount(), 0, initiationInterval_);
    ResourceBroker::addResource(*gcu, fuResource);
}

References ResourceBroker::addResource(), TTAMachine::Machine::controlUnit(), TTAMachine::Machine::Navigator< ComponentType >::count(), TTAMachine::Machine::functionUnitNavigator(), ResourceBroker::initiationInterval_, TTAMachine::Machine::Navigator< ComponentType >::item(), TTAMachine::Component::name(), and TTAMachine::FunctionUnit::operationCount().

Here is the call graph for this function:

◆ earliestCycle()

int InputFUBroker::earliestCycle	(	int	cycle,
		const MoveNode &	node,
		const TTAMachine::Bus *	bus,
		const TTAMachine::FunctionUnit *	srcFU,
		const TTAMachine::FunctionUnit *	dstFU,
		int	immWriteCycle,
		const TTAMachine::ImmediateUnit *	immu,
		int	immRegIndex
	)		const

overridevirtual

Return the earliest cycle, starting from given cycle, where a resource of the type managed by this broker can be assigned to the given node.

Parameters

cycle	Cycle.
node	Node.

Returns: The earliest cycle, starting from given cycle, where a resource of the type managed by this broker can be assigned to the given node.

Implements ResourceBroker.

Definition at line 320 of file InputFUBroker.cc.

                                                                        {
    abortWithError("Not implemented.");
    return -1;
}

References abortWithError.

◆ isAlreadyAssigned()

bool InputFUBroker::isAlreadyAssigned	(	int	cycle,
		const MoveNode &	node,
		const TTAMachine::Bus *	preassignedBus
	)		const

overridevirtual

Return true if the given node is already assigned a resource of the type managed by this broker, and the assignment appears valid (that is, the broker has marked that resource as in use in the given cycle).

Parameters

cycle	Cycle. Not used.
node	Node.

Returns: True if the given node is already assigned a resource of the type managed by this broker, and the assignment appears valid (that is, the broker has marked that resource as in use in the given cycle) and recorded for node that it is using it (could be inUse because some other operation is executed).

Implements ResourceBroker.

Definition at line 365 of file InputFUBroker.cc.

                                                                 {
    cycle = instructionIndex(cycle);
    Terminal& dst = const_cast<MoveNode&>(node).move().destination();
    if (dst.isFUPort()) {
        const FunctionUnit& fu = dst.functionUnit();
        if (hasResourceOf(fu)) {
            if (MapTools::containsKey(assignedResources_, &node)){
                return true;
            }
        }
    }
    return false;
}

References ResourceBroker::assignedResources_, MapTools::containsKey(), TTAProgram::Terminal::functionUnit(), ResourceBroker::hasResourceOf(), ResourceBroker::instructionIndex(), and TTAProgram::Terminal::isFUPort().

Here is the call graph for this function:

◆ isApplicable()

bool InputFUBroker::isApplicable	(	const MoveNode &	node,
		const TTAMachine::Bus *	preAssigndBus = `0`
	)		const

overridevirtual

Return true if the given node needs a resource of the type managed by this broker, false otherwise.

Parameters

node Node.

Returns: True if the given node needs a resource of the type managed by this broker, false otherwise.

Implements ResourceBroker.

Definition at line 389 of file InputFUBroker.cc.

                                                      {
    if (!node.isMove()) {
        return false;
    }
    Move& move = const_cast<MoveNode&>(node).move();
    return move.destination().isFUPort();
}

References TTAProgram::Move::destination(), TTAProgram::Terminal::isFUPort(), and MoveNode::isMove().

Referenced by allAvailableResources(), assign(), and unassign().

Here is the call graph for this function:

◆ latestCycle()

int InputFUBroker::latestCycle	(	int	cycle,
		const MoveNode &	node,
		const TTAMachine::Bus *	bus,
		const TTAMachine::FunctionUnit *	srcFU,
		const TTAMachine::FunctionUnit *	dstFU,
		int	immWriteCycle,
		const TTAMachine::ImmediateUnit *	immu,
		int	immRegIndex
	)		const

overridevirtual

Return the latest cycle, starting from given cycle, where a resource of the type managed by this broker can be assigned to the given node.

Parameters

cycle	Cycle.
node	Node.

Returns: The latest cycle, starting from given cycle, where a resource of the type managed by this broker can be assigned to the given node.

Implements ResourceBroker.

Definition at line 341 of file InputFUBroker.cc.

                                                                      {
    abortWithError("Not implemented.");
    return -1;
}

References abortWithError.

◆ setupResourceLinks()

void InputFUBroker::setupResourceLinks ( const ResourceMapper & mapper )

overridevirtual

Complete resource initialisation by creating the references to other resources due to a dependency or a relation. Use the given resource mapper to lookup dependent and related resources using machine parts as keys.

Parameters

mapper Resource mapper.

Implements ResourceBroker.

Definition at line 531 of file InputFUBroker.cc.

                                                              {
 
    setResourceMapper(mapper);
 
    for (ResourceMap::iterator resIter = resMap_.begin();
         resIter != resMap_.end(); resIter++) {
 
        const FunctionUnit* fu =
            dynamic_cast<const FunctionUnit*>((*resIter).first);
        if (fu == NULL){
            throw InvalidData(
                __FILE__, __LINE__, __func__, 
                "Broker has other resource then FU registered!");                               
        }
 
        SchedulingResource* fuResource = (*resIter).second;
 
        for (int i = 0; i < fu->portCount(); i++) {
            Port* port = fu->port(i);
            if (port->inputSocket() != NULL) {
                SchedulingResource& depRes =
                    mapper.resourceOf(*port->inputSocket());
                fuResource->addToDependentGroup(0, depRes);
            }
        }
 
        int fuCount = mapper.resourceCount(*fu);
        for (int i = 0; i < fuCount; i++) {
            SchedulingResource* depRes = &mapper.resourceOf(*fu, i);
            if (depRes->isExecutionPipelineResource()){
                fuResource->addToDependentGroup(1, *depRes);
                break;
            }
        }
    }
}

References __func__, SchedulingResource::addToDependentGroup(), TTAMachine::Port::inputSocket(), SchedulingResource::isExecutionPipelineResource(), TTAMachine::FunctionUnit::port(), TTAMachine::Unit::portCount(), ResourceBroker::resMap_, ResourceMapper::resourceCount(), ResourceMapper::resourceOf(), and ResourceBroker::setResourceMapper().

Here is the call graph for this function:

◆ unassign()

void InputFUBroker::unassign ( MoveNode & node )

overridevirtual

Free the resource type managed by this broker and unassign it from given node.

If this broker is not applicable to the given node, or the node is not assigned a resource of the managed type, this method does nothing.

Parameters

node Node.

Implements ResourceBroker.

Definition at line 474 of file InputFUBroker.cc.

                                      {
    if (!isApplicable(node)) {
        return;
    }
    if (!MapTools::containsKey(assignedResources_, &node)) {
        return;
    } else {
        Move& move = const_cast<MoveNode&>(node).move();
        TerminalFUPort& dst =
            static_cast<TerminalFUPort&>(move.destination());
        InputFUResource& res =
            static_cast<InputFUResource&>(*resourceOf(dst.functionUnit()));
        res.unassign(node.cycle(), node);
        assignedResources_.erase(&node);
        return;
    }
 
}

References ResourceBroker::assignedResources_, MapTools::containsKey(), MoveNode::cycle(), TTAProgram::Move::destination(), TTAProgram::TerminalFUPort::functionUnit(), isApplicable(), ResourceBroker::resourceOf(), and InputFUResource::unassign().

Here is the call graph for this function:

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

Public Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ InputFUBroker()

◆ ~InputFUBroker()

Member Function Documentation

◆ allAvailableResources()

◆ assign()

◆ buildResources()

◆ earliestCycle()

◆ isAlreadyAssigned()

◆ isApplicable()

◆ latestCycle()

◆ setupResourceLinks()

◆ unassign()