InputFUBroker Class Reference

#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.

                             {
}

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(), TTAMachine::HWOperation::port(), TTAProgram::TerminalFUPort::port(), ResourceBroker::resMap_, ResourceBroker::resourceMapper(), ResourceMapper::resourceOf(), ResourceBroker::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:

• InputFUBroker.hh
• InputFUBroker.cc