#include <OutputPSocketBroker.hh>

Inheritance diagram for OutputPSocketBroker:

Collaboration diagram for OutputPSocketBroker:

Public Member Functions
	OutputPSocketBroker (std::string name, ResourceBroker &ofb, SimpleResourceManager *, unsigned int initiationInterval=0)

virtual	~OutputPSocketBroker ()

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 override

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 void	assign (int cycle, MoveNode &node, SchedulingResource &res, int immWriteCycle, int immRegIndex) override

virtual void	unassign (MoveNode &node) 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 *b) const override

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

virtual void	setupResourceLinks (const ResourceMapper &mapper) override

void	setBusBroker (ResourceBroker &sb)

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

virtual	~ResourceBroker ()

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)

Private Attributes
ResourceBroker &	outputFUBroker_

ResourceBroker *	busBroker_

SimpleResourceManager *	rm_

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

Output p-socket broker.

Definition at line 51 of file OutputPSocketBroker.hh.

Constructor & Destructor Documentation

◆ OutputPSocketBroker()

OutputPSocketBroker::OutputPSocketBroker	(	std::string	name,
		ResourceBroker &	fub,
		SimpleResourceManager *	rm,
		unsigned int	initiationInterval = `0`
	)

Constructor.

Parameters

name	name for this broker.
fub	reference to OutputFUBroker of this resource manager.
initiationInterval	initiationinterval when doing loop scheduling.

Definition at line 57 of file OutputPSocketBroker.cc.

                                     : 
    ResourceBroker(name, initiationInterval), 
    outputFUBroker_(fub), busBroker_(NULL), rm_(rm) {
}

◆ ~OutputPSocketBroker()

OutputPSocketBroker::~OutputPSocketBroker ( )

virtual

Destructor.

Definition at line 69 of file OutputPSocketBroker.cc.

69 {

70}

Member Function Documentation

◆ allAvailableResources()

SchedulingResourceSet OutputPSocketBroker::allAvailableResources	(	int	cycle,
		const MoveNode &	node,
		const TTAMachine::Bus *	preassignedBus,
		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 82 of file OutputPSocketBroker.cc.

                                               {
 
    cycle = instructionIndex(cycle);
    if (!isApplicable(node, preassignedBus)) {
        string msg = "Broker not capable of assigning resources to node!";
        throw ModuleRunTimeError(__FILE__, __LINE__, __func__, msg);
    }
 
    TTAProgram::Move& move = const_cast<MoveNode&>(node).move();
 
    SchedulingResourceSet resourceSet;
 
    if (move.source().isFUPort()) {
        // psocket is implicit by fubroker choice of FU
        Socket& outputSocket = *move.source().port().outputSocket();
        SchedulingResource* res = resourceOf(outputSocket);
        if (res->canAssign(cycle,node)) {
            resourceSet.insert(*res);
        }
        return resourceSet;
    }
    if (move.source().isGPR()) {
        // assign psocket for reading rf
        const RegisterFile& rf = move.source().registerFile();
        for (int i = 0; i < rf.portCount(); i++) {
            Port& port = *rf.port(i);
            Socket* outputSocket = port.outputSocket();
            
            if (outputSocket != NULL) {
                SchedulingResource* res = resourceOf(*outputSocket);
                if (res->canAssign(cycle, node)) {
                    resourceSet.insert(*res);
                }
            }
        }
        return resourceSet;
    }
    if (move.source().isImmediateRegister()) {
        // assign psocket for reading IU
        const ImmediateUnit& iu = move.source().immediateUnit();
        for (int i = 0; i < iu.portCount(); i++) {
            Port& port = *iu.port(i);
            Socket* outputSocket = port.outputSocket();
            if (outputSocket != NULL) {
                SchedulingResource* res = resourceOf(*outputSocket);
                if (res->canAssign(cycle, node)) {
                    resourceSet.insert(*res);
                }
            }
        }
    }
    return resourceSet;
}

References __func__, SchedulingResource::canAssign(), TTAProgram::Terminal::immediateUnit(), SchedulingResourceSet::insert(), ResourceBroker::instructionIndex(), isApplicable(), TTAProgram::Terminal::isFUPort(), TTAProgram::Terminal::isGPR(), TTAProgram::Terminal::isImmediateRegister(), TTAMachine::Port::outputSocket(), TTAProgram::Terminal::port(), TTAMachine::BaseRegisterFile::port(), TTAMachine::Unit::portCount(), TTAProgram::Terminal::registerFile(), ResourceBroker::resourceOf(), and TTAProgram::Move::source().

Here is the call graph for this function:

◆ assign()

void OutputPSocketBroker::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 Output PSocket

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 237 of file OutputPSocketBroker.cc.

              {
 
    cycle = instructionIndex(cycle);
    if (!hasResource(res)) {
        string msg = "Broker does not contain given resource.";
        throw InvalidData(__FILE__, __LINE__, __func__, msg);
    }
 
    TTAProgram::Move& move = node.move();
 
    if (move.source().isGPR() || move.source().isImmediateRegister()) {
 
        Port* port = NULL;
        const Socket& socket =
            static_cast<const Socket&>(machinePartOf(res));
        for (int i = 0; i < socket.portCount(); i++) {
            if (socket.port(i)->outputSocket() == &socket) {
                if ((move.source().isGPR() &&
                     socket.port(i)->parentUnit() !=
                     &move.source().registerFile()) ||
                    (move.source().isImmediateRegister() &&
                     socket.port(i)->parentUnit() !=
                     &move.source().immediateUnit()))
                    continue;
                port = socket.port(i);
                break;
            }
        }
        if (port == NULL) {
            throw InvalidData(
                __FILE__, __LINE__, __func__, 
                "Broker can not find necesary Port!");
        }
        TTAProgram::TerminalRegister* newSrc = new TerminalRegister(
            *port, move.source().index());
        move.setSource(newSrc);
    }
    res.assign(cycle, node);
    assignedResources_.insert(
        std::pair<const MoveNode*, SchedulingResource*>(&node, &res));
}

References __func__, SchedulingResource::assign(), ResourceBroker::assignedResources_, ResourceBroker::hasResource(), TTAProgram::Terminal::immediateUnit(), TTAProgram::Terminal::index(), ResourceBroker::instructionIndex(), TTAProgram::Terminal::isGPR(), TTAProgram::Terminal::isImmediateRegister(), ResourceBroker::machinePartOf(), MoveNode::move(), TTAMachine::Port::outputSocket(), TTAMachine::Port::parentUnit(), TTAMachine::Socket::port(), TTAMachine::Socket::portCount(), TTAProgram::Terminal::registerFile(), TTAProgram::Move::setSource(), and TTAProgram::Move::source().

Here is the call graph for this function:

◆ buildResources()

void OutputPSocketBroker::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 429 of file OutputPSocketBroker.cc.

                                                                   {
 
    Machine::SocketNavigator navi = target.socketNavigator();
 
    for (int i = 0; i < navi.count(); i++) {
        Socket* socket = navi.item(i);
        if (socket->direction() == Socket::OUTPUT) {
            OutputPSocketResource* opsResource =
                new OutputPSocketResource(socket->name(), initiationInterval_);
            ResourceBroker::addResource(*socket, opsResource);
        }
    }
}

References ResourceBroker::addResource(), TTAMachine::Machine::Navigator< ComponentType >::count(), TTAMachine::Socket::direction(), ResourceBroker::initiationInterval_, TTAMachine::Machine::Navigator< ComponentType >::item(), TTAMachine::Component::name(), TTAMachine::Socket::OUTPUT, and TTAMachine::Machine::socketNavigator().

Here is the call graph for this function:

◆ earliestCycle()

int OutputPSocketBroker::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 316 of file OutputPSocketBroker.cc.

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

References abortWithError.

◆ isAlreadyAssigned()

bool OutputPSocketBroker::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.
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).

Implements ResourceBroker.

Definition at line 362 of file OutputPSocketBroker.cc.

                                                                     {
    cycle = instructionIndex(cycle);
    if (node.isSourceConstant() && 
        node.move().hasAnnotations(
            TTAProgram::ProgramAnnotation::ANN_REQUIRES_LIMM)) {
        return true;
    }    
    if (node.isSourceConstant() && rm_ &&
        !rm_->canTransportImmediate(node, preassignedBus)) {
        return true;
    }
    Terminal& src = const_cast<MoveNode&>(node).move().source();
    if (src.isFUPort() || src.isGPR() || src.isImmediateRegister()) {
        const Port& port = src.port();
        if (port.outputSocket() == NULL)
            return false;
        SchedulingResource* res = resourceOf(*port.outputSocket());
        if (res != NULL && res->isInUse(cycle) &&
            MapTools::containsKey(assignedResources_, &node)) {
            return true;
        }
    }
    return false;
}

References TTAProgram::ProgramAnnotation::ANN_REQUIRES_LIMM, ResourceBroker::assignedResources_, SimpleResourceManager::canTransportImmediate(), MapTools::containsKey(), TTAProgram::AnnotatedInstructionElement::hasAnnotations(), ResourceBroker::instructionIndex(), TTAProgram::Terminal::isFUPort(), TTAProgram::Terminal::isGPR(), TTAProgram::Terminal::isImmediateRegister(), SchedulingResource::isInUse(), MoveNode::isSourceConstant(), MoveNode::move(), TTAMachine::Port::outputSocket(), TTAProgram::Terminal::port(), ResourceBroker::resourceOf(), and rm_.

Here is the call graph for this function:

◆ isAnyResourceAvailable()

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

overridevirtual

Return true if one of the resources managed by this broker is suitable for the request contained in the node and can be assigned to it in given cycle.

Parameters

cycle	Cycle.
node	Node.

Returns: True if one of the resources managed by this broker is suitable for the request contained in the node and can be assigned to it in given cycle.

Reimplemented from ResourceBroker.

Definition at line 155 of file OutputPSocketBroker.cc.

                                               {
 
    cycle = instructionIndex(cycle);
    if (!isApplicable(node, preassignedBus)) {
        string msg = "Broker not capable of assigning resources to node!";
        throw ModuleRunTimeError(__FILE__, __LINE__, __func__, msg);
    }
 
    TTAProgram::Move& move = const_cast<MoveNode&>(node).move();
 
    SchedulingResourceSet resourceSet;
 
    if (move.source().isFUPort()) {
        // psocket is implicit by fubroker choice of FU
        Socket& outputSocket = *move.source().port().outputSocket();
        SchedulingResource* res = resourceOf(outputSocket);
        if (res->canAssign(cycle,node)) {
            return true;
        } else {
            return false;
        }
    }
    if (move.source().isGPR()) {
        // assign psocket for reading rf
        const RegisterFile& rf = move.source().registerFile();
        for (int i = 0; i < rf.portCount(); i++) {
            Port& port = *rf.port(i);
            Socket* outputSocket = port.outputSocket();
            
            if (outputSocket != NULL) {
                SchedulingResource* res = resourceOf(*outputSocket);
                if (res->canAssign(cycle, node)) {
                    return true;
                }
            }
        }
        return false;
    }
    if (move.source().isImmediateRegister()) {
        // assign psocket for reading IU
        const ImmediateUnit& iu = move.source().immediateUnit();
        for (int i = 0; i < iu.portCount(); i++) {
            Port& port = *iu.port(i);
            Socket* outputSocket = port.outputSocket();
            if (outputSocket != NULL) {
                SchedulingResource* res = resourceOf(*outputSocket);
                if (res->canAssign(cycle, node)) {
                    return true;
                }
            }
        }
        return false;
    }
    return false;
}

References __func__, SchedulingResource::canAssign(), TTAProgram::Terminal::immediateUnit(), ResourceBroker::instructionIndex(), isApplicable(), TTAProgram::Terminal::isFUPort(), TTAProgram::Terminal::isGPR(), TTAProgram::Terminal::isImmediateRegister(), TTAMachine::Port::outputSocket(), TTAProgram::Terminal::port(), TTAMachine::BaseRegisterFile::port(), TTAMachine::Unit::portCount(), TTAProgram::Terminal::registerFile(), ResourceBroker::resourceOf(), and TTAProgram::Move::source().

Here is the call graph for this function:

◆ isApplicable()

bool OutputPSocketBroker::isApplicable	(	const MoveNode &	node,
		const TTAMachine::Bus *	preassignedBus
	)		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 398 of file OutputPSocketBroker.cc.

                                                                     {
    if (!node.isMove()) {
        return false;
    }
    Move& move = const_cast<MoveNode&>(node).move();
    // If node is annotated, it will be converted to LIMM
    // and so we will need to assign output PScoket
    if (node.isSourceConstant() && node.move().hasAnnotations(
            TTAProgram::ProgramAnnotation::ANN_REQUIRES_LIMM)) {
        return true;
    }    
    if (node.isSourceConstant() &&
        rm_ && !rm_->canTransportImmediate(node, preassignedBus)) {
        return true;
    }
    return (move.source().isFUPort() ||
        move.source().isGPR() ||
        move.source().isImmediateRegister());
}

References TTAProgram::ProgramAnnotation::ANN_REQUIRES_LIMM, SimpleResourceManager::canTransportImmediate(), TTAProgram::AnnotatedInstructionElement::hasAnnotations(), TTAProgram::Terminal::isFUPort(), TTAProgram::Terminal::isGPR(), TTAProgram::Terminal::isImmediateRegister(), MoveNode::isMove(), MoveNode::isSourceConstant(), MoveNode::move(), rm_, and TTAProgram::Move::source().

Referenced by allAvailableResources(), and isAnyResourceAvailable().

Here is the call graph for this function:

◆ latestCycle()

int OutputPSocketBroker::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 338 of file OutputPSocketBroker.cc.

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

References abortWithError.

◆ setBusBroker()

void OutputPSocketBroker::setBusBroker ( ResourceBroker & sb )

Gives reference to segmentbroker to this broker.

Cannot be given in constructor because SegmentBroker is created later.

Definition at line 511 of file OutputPSocketBroker.cc.

                                                         {
    busBroker_ = &sb;
}

References busBroker_.

Referenced by SimpleResourceManager::buildResourceModel().

◆ setupResourceLinks()

void OutputPSocketBroker::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 452 of file OutputPSocketBroker.cc.

                                                                    {
 
    setResourceMapper(mapper);
 
    for (ResourceMap::iterator resIter = resMap_.begin();
         resIter != resMap_.end(); resIter++) {
 
        const Socket* socket =
            static_cast<const Socket*>((*resIter).first);
 
        SchedulingResource* socketResource = (*resIter).second;
 
        for (int i = 0; i < socket->portCount(); i++) {
            Port* port = socket->port(i);
            Unit* unit = port->parentUnit();
            if (dynamic_cast<FunctionUnit*>(unit) != NULL) {
 
                SchedulingResource& relRes = 
                    *outputFUBroker_.resourceOf(*unit);
                socketResource->addToRelatedGroup(0, relRes);
            } else if (dynamic_cast<ImmediateUnit*>(unit) != NULL) {
                try {
                    SchedulingResource& relRes = mapper.resourceOf(*unit);
                    socketResource->addToRelatedGroup(1, relRes);
                } catch (const KeyNotFound& e) {
                    std::string msg = "OutputPSocketBroker: finding ";
                    msg += " resource for IU ";
                    msg += " failed with error: ";
                    msg += e.errorMessageStack();
                    throw KeyNotFound(
                        __FILE__, __LINE__, __func__, msg);
                }                                                            
            }
        }
 
        for (int i = 0; i < socket->segmentCount(); i++) {
            try {
                Segment* segment = socket->segment(i);
                Bus* bus = segment->parentBus();
                SchedulingResource& relRes = 
                    *busBroker_->resourceOf(*bus);
                socketResource->addToRelatedGroup(2, relRes);
            } catch (const KeyNotFound& e) {
                std::string msg = "OutputPSocketBroker: finding ";
                msg += " resource for Segment ";
                msg += " failed with error: ";
                msg += e.errorMessageStack();
                throw KeyNotFound(
                    __FILE__, __LINE__, __func__, msg);
            }                                                                        
        }
    }
}

References __func__, SchedulingResource::addToRelatedGroup(), busBroker_, Exception::errorMessageStack(), outputFUBroker_, TTAMachine::Segment::parentBus(), TTAMachine::Port::parentUnit(), TTAMachine::Socket::port(), TTAMachine::Socket::portCount(), ResourceBroker::resMap_, ResourceBroker::resourceOf(), ResourceMapper::resourceOf(), TTAMachine::Socket::segment(), TTAMachine::Socket::segmentCount(), and ResourceBroker::setResourceMapper().

Here is the call graph for this function:

◆ unassign()

void OutputPSocketBroker::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 294 of file OutputPSocketBroker.cc.

                                            {
    if (MapTools::containsKey(assignedResources_, &node)) {
        SchedulingResource* res = 
            MapTools::valueForKey<SchedulingResource*>(
                    assignedResources_,&node);
        res->unassign(node.cycle(), node);
        assignedResources_.erase(&node);
    }
}

References ResourceBroker::assignedResources_, MapTools::containsKey(), MoveNode::cycle(), MapTools::keyForValue(), and SchedulingResource::unassign().

Here is the call graph for this function:

Member Data Documentation

◆ busBroker_

ResourceBroker* OutputPSocketBroker::busBroker_

private

Definition at line 105 of file OutputPSocketBroker.hh.

Referenced by setBusBroker(), and setupResourceLinks().

◆ outputFUBroker_

ResourceBroker& OutputPSocketBroker::outputFUBroker_

private

Definition at line 104 of file OutputPSocketBroker.hh.

Referenced by setupResourceLinks().

◆ rm_

SimpleResourceManager* OutputPSocketBroker::rm_

private

Definition at line 108 of file OutputPSocketBroker.hh.

Referenced by isAlreadyAssigned(), and isApplicable().

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

Public Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ OutputPSocketBroker()

◆ ~OutputPSocketBroker()

Member Function Documentation

◆ allAvailableResources()

◆ assign()

◆ buildResources()

◆ earliestCycle()

◆ isAlreadyAssigned()

◆ isAnyResourceAvailable()

◆ isApplicable()

◆ latestCycle()

◆ setBusBroker()

◆ setupResourceLinks()

◆ unassign()

Member Data Documentation

◆ busBroker_

◆ outputFUBroker_

◆ rm_