#include <OutputFUBroker.hh>

Inheritance diagram for OutputFUBroker:

Collaboration diagram for OutputFUBroker:

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

virtual	~OutputFUBroker ()

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=0) const 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

Output function unit broker.

Definition at line 50 of file OutputFUBroker.hh.

Constructor & Destructor Documentation

◆ OutputFUBroker()

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

Constructor.

Definition at line 65 of file OutputFUBroker.cc.

                                                                               :
     FUBroker(name, initiationInterval) {
 }

◆ ~OutputFUBroker()

OutputFUBroker::~OutputFUBroker ( )

virtual

Destructor.

Definition at line 72 of file OutputFUBroker.cc.

72 {

73 }

Member Function Documentation

◆ allAvailableResources()

SchedulingResourceSet OutputFUBroker::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 85 of file OutputFUBroker.cc.

                {
  
     int modCycle = instructionIndex(cycle);
     if (!isApplicable(node)) {
         string msg = "Broker not capable of assigning resources to node: "
         + node.toString();
         throw ModuleRunTimeError(__FILE__, __LINE__, __func__, msg);
     }
  
     const TTAMachine::FunctionUnit* foundFU = srcFU;
     int opIndex = -1;
     ProgramOperation* PO = nullptr;
     SchedulingResourceSet resourceSet;
     ResourceMap::const_iterator resIter = resMap_.begin();
  
     const Operation* op = nullptr;
  
     if (node.move().source().isFUPort()) {
         TerminalFUPort& src =
             static_cast<TerminalFUPort&>(node.move().source());
  
         if (dynamic_cast<const SpecialRegisterPort*>(&src.port()) != NULL) {
             // only gcu applies
             while (resIter != resMap_.end()) {
                 const ControlUnit* gcu =
                     dynamic_cast<const ControlUnit*>((*resIter).first);
                 if (gcu != NULL) {
                     if ((*resIter).second->isAvailable(modCycle)) {
                         resourceSet.insert(*(*resIter).second);
                     }
                     return resourceSet;
                 }
                 resIter++;
             }
             abortWithError("No GCU found!");
         }
  
         op = &src.hintOperation();
         opIndex = src.operationIndex();
  
         // check if a unit has already been assigned to some node
         // of the same operation and use it.
         if (node.isSourceOperation()) {
             PO = &node.sourceOperation();
         } else {
             assert(false);
         }
     } else {
         // port guard?
         PO = &node.guardOperation();
         opIndex = PO->outputIndexFromGuardOfMove(node);
         op = &PO->operation();
     }
  
     auto a = findFUOfPO(*PO, foundFU);
     if (a.first) {
         foundFU = a.second;
     } else { // conflicting FUs, cannot schedule
         return SchedulingResourceSet();
     }
  
     if (foundFU) {
         OutputFUResource& fuRes =
             static_cast<OutputFUResource&>(*resourceOf(*foundFU));
         // Find what is the port on a new FU for given
         // operation index. Find a socket for testing.
         HWOperation* hwOp = foundFU->operation(op->name());
         assert(hwOp != nullptr);
         Port* resultPort = hwOp->port(opIndex);
         assert (resultPort != nullptr);
         if (fuRes.canAssign(cycle, node, *resultPort)) {
             resourceSet.insert(fuRes);
         }
         return resourceSet;
     }
  
     // 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;
     std::set<TCEString> rejectedFUs;
  
     // TODO: why is this in loop for operands but not in loop for results?
     // do multiple return values break or work?
     MachineConnectivityCheck::addAnnotatedFUs(
         candidateFUs, node.move(),
         TTAProgram::ProgramAnnotation::ANN_CONN_CANDIDATE_UNIT_SRC);
     MachineConnectivityCheck::addAnnotatedFUs(
         allowedFUs, node.move(),
         TTAProgram::ProgramAnnotation::ANN_ALLOWED_UNIT_SRC);
     MachineConnectivityCheck::addAnnotatedFUs(
         rejectedFUs, node.move(),
         TTAProgram::ProgramAnnotation::ANN_REJECTED_UNIT_SRC);
  
     // find units that support operation and are available at given cycle
     while (resIter != resMap_.end()) {
         const FunctionUnit* unit =
             static_cast<const FunctionUnit*>((*resIter).first);
         if (srcFU != NULL && unit != srcFU) {
             debugLogRM(TCEString("Skipping unit") << unit->name()
                        << " because it's not the pre-set one: "
                        << srcFU->name());
             resIter++;
             continue;
         }
         // 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())) {
             ++resIter;
             continue;
         }
         if (allowedFUs.size() > 0 &&
             !AssocTools::containsKey(allowedFUs, unit->name())) {
             debugLogRM(
                 TCEString("skipped ") << unit->name() << " because it was not"
                 " in the allowed set. The set contents: ");
             for (auto allowedUnit : allowedFUs)
                 debugLogRM(allowedUnit + "\n");
             ++resIter;
             continue;
         }
  
         if (AssocTools::containsKey(rejectedFUs, unit->name())) {
             debugLogRM(
                 TCEString("skipped ") << unit->name() << " because it was"
                 " in the rejected set.");
             ++resIter;
             continue;
         }            
  
         if (unit->hasOperation(op->name())) {
             OutputFUResource& fuRes =
                 static_cast<OutputFUResource&>(*resourceOf(*unit));
                 // Find what is the port on a new FU for given
                 // operation index. Find a socket for testing.
             HWOperation* hwOp = unit->operation(op->name());
             Port* resultPort = hwOp->port(opIndex);
             if (fuRes.canAssign(cycle, node, *resultPort)) {
                 debugLogRM("testing " + op->name());
                 resourceSet.insert(*(*resIter).second);
             } else {
                 debugLogRM("could not assign the fuRes to it.");
             }
         } else {
             debugLogRM(TCEString("does not have operation ") + op->name());
         }
         resIter++;
     }
     return resourceSet;
 }

References __func__, abortWithError, MachineConnectivityCheck::addAnnotatedFUs(), TTAProgram::ProgramAnnotation::ANN_ALLOWED_UNIT_SRC, TTAProgram::ProgramAnnotation::ANN_CONN_CANDIDATE_UNIT_SRC, TTAProgram::ProgramAnnotation::ANN_REJECTED_UNIT_SRC, assert, OutputFUResource::canAssign(), AssocTools::containsKey(), debugLogRM, FUBroker::findFUOfPO(), MoveNode::guardOperation(), TTAMachine::FunctionUnit::hasOperation(), TTAProgram::TerminalFUPort::hintOperation(), SchedulingResourceSet::insert(), ResourceBroker::instructionIndex(), isApplicable(), TTAProgram::Terminal::isFUPort(), MoveNode::isSourceOperation(), MoveNode::move(), TTAMachine::Component::name(), Operation::name(), TTAMachine::FunctionUnit::operation(), ProgramOperation::operation(), TTAProgram::TerminalFUPort::operationIndex(), ProgramOperation::outputIndexFromGuardOfMove(), TTAMachine::HWOperation::port(), TTAProgram::TerminalFUPort::port(), ResourceBroker::resMap_, ResourceBroker::resourceOf(), TTAProgram::Move::source(), MoveNode::sourceOperation(), and MoveNode::toString().

Here is the call graph for this function:

◆ assign()

void OutputFUBroker::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 of 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 261 of file OutputFUBroker.cc.

                                                                   {
     // TODO: this breaks execpipeline
 //    cycle = instructionIndex(cycle);
     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);
     }
     OutputFUResource& fuRes = static_cast<OutputFUResource&>(res);
     Move& move = const_cast<MoveNode&>(node).move();
  
     int opIndex = -1;
     const Operation* op = nullptr;
     TerminalFUPort* src = dynamic_cast<TerminalFUPort*>(&move.source());
     if (src != nullptr &&
         dynamic_cast<const SpecialRegisterPort*>(&src->port()) != NULL) {
         const ControlUnit* gcu =
             dynamic_cast<const ControlUnit*>(&machinePartOf(res));
         if (gcu != NULL) {
             // output of GCU is ra read
             TerminalFUPort* newSrc =
                 new TerminalFUPort(*gcu->returnAddressPort());
             move.setSource(newSrc);
             Socket* outputSocket = newSrc->port().outputSocket();
             
             if (outputSocket == NULL) {
                 throw InvalidData(
                     __FILE__, __LINE__, __func__, "GCU is missing RA port - "
                     "socket connection!");
             }
             assignedResources_.insert(
                 std::pair<const MoveNode*, SchedulingResource*>(
                 &node, &fuRes));
             return;
         } else {
             abortWithError(
                 "GCU required but tried to assign something else!");
         }
     }
  
     if (node.isSourceOperation()) {
  
         opIndex = src->operationIndex();
         op = &src->hintOperation();
         const FunctionUnit& unit =
             static_cast<const FunctionUnit&>(machinePartOf(res));
         HWOperation* hwOp = unit.operation(op->name());
         TerminalFUPort* newSrc = new TerminalFUPort(*hwOp, opIndex);
         move.setSource(newSrc);
         fuRes.assign(cycle, node);
         assignedResources_.insert(
             std::pair<const MoveNode*, SchedulingResource*>(
                 &node, &fuRes));
     } else {
         assert(node.isGuardOperation());
         ProgramOperation& po = node.guardOperation();
         opIndex = po.outputIndexOfMove(node);
         op = &po.operation();
  
         fuRes.assign(cycle, node);
         assignedResources_.insert(
             std::pair<const MoveNode*, SchedulingResource*>(
                 &node, &fuRes));
     }
 }

References __func__, abortWithError, assert, OutputFUResource::assign(), ResourceBroker::assignedResources_, MoveNode::guardOperation(), ResourceBroker::hasResource(), TTAProgram::TerminalFUPort::hintOperation(), isApplicable(), MoveNode::isGuardOperation(), MoveNode::isSourceOperation(), ResourceBroker::machinePartOf(), Operation::name(), TTAMachine::FunctionUnit::operation(), ProgramOperation::operation(), TTAProgram::TerminalFUPort::operationIndex(), ProgramOperation::outputIndexOfMove(), TTAMachine::Port::outputSocket(), TTAProgram::TerminalFUPort::port(), TTAMachine::ControlUnit::returnAddressPort(), TTAProgram::Move::setSource(), and TTAProgram::Move::source().

Here is the call graph for this function:

◆ buildResources()

void OutputFUBroker::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 489 of file OutputFUBroker.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);
         OutputFUResource* fuResource = new OutputFUResource(
             fu->name(), fu->operationCount(), nopWeights[fu]);
         ResourceBroker::addResource(*fu, fuResource);
     }
     ControlUnit* gcu = target.controlUnit();
     OutputFUResource* fuResource = new OutputFUResource(
         gcu->name(), gcu->operationCount(),0);
     ResourceBroker::addResource(*gcu, fuResource);
 }

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

Here is the call graph for this function:

◆ earliestCycle()

int OutputFUBroker::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 387 of file OutputFUBroker.cc.

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

References abortWithError.

◆ isAlreadyAssigned()

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

Implements ResourceBroker.

Definition at line 432 of file OutputFUBroker.cc.

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

References ResourceBroker::assignedResources_, MapTools::containsKey(), ProgramOperation::fuFromOutMove(), TTAProgram::Terminal::functionUnit(), MoveNode::guardOperation(), ResourceBroker::hasResourceOf(), ResourceBroker::instructionIndex(), TTAProgram::Terminal::isFUPort(), and MoveNode::isGuardOperation().

Here is the call graph for this function:

◆ isApplicable()

bool OutputFUBroker::isApplicable	(	const MoveNode &	node,
		const TTAMachine::Bus *	b = `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 464 of file OutputFUBroker.cc.

                                                       {
     if (!node.isMove()) {
         return false;
     }
     Move& move = const_cast<MoveNode&>(node).move();
     if (move.source().isFUPort() ||
         (!move.isUnconditional() &&
          dynamic_cast<const TTAMachine::PortGuard*>(&move.guard().guard()))) {
         return true;
     } else {
         return false;
     }
 }

References TTAProgram::MoveGuard::guard(), TTAProgram::Move::guard(), TTAProgram::Terminal::isFUPort(), MoveNode::isMove(), TTAProgram::Move::isUnconditional(), and TTAProgram::Move::source().

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

Here is the call graph for this function:

◆ latestCycle()

int OutputFUBroker::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 409 of file OutputFUBroker.cc.

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

References abortWithError.

◆ setupResourceLinks()

void OutputFUBroker::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 515 of file OutputFUBroker.cc.

                                                                {
  
     setResourceMapper(mapper);
  
     for (ResourceMap::iterator resIter = resMap_.begin();
          resIter != resMap_.end(); resIter++) {
  
         const FunctionUnit* fu =
             dynamic_cast<const FunctionUnit*>((*resIter).first);
  
         SchedulingResource* fuResource = (*resIter).second;
         for (int i = 0; i < fu->portCount(); i++) {
             Port* port = fu->port(i);
             if (port->outputSocket() != NULL) {
                 try {
                     SchedulingResource& depRes =
                         mapper.resourceOf(*port->outputSocket());
                     fuResource->addToDependentGroup(0, depRes);
                 } catch (const KeyNotFound& e) {
                     std::string msg = "OutputFUBroker: finding ";
                     msg += " resource for Socket ";
                     msg += " failed with error: ";
                     msg += e.errorMessageStack();
                     throw KeyNotFound(
                         __FILE__, __LINE__, __func__, msg);
                 }                                
             }
         }
  
         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;
             }
         }
     }
     // todo: dependent execution pipeline to support trigger-on-result
 }

References __func__, SchedulingResource::addToDependentGroup(), Exception::errorMessageStack(), SchedulingResource::isExecutionPipelineResource(), TTAMachine::Port::outputSocket(), 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 OutputFUBroker::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 343 of file OutputFUBroker.cc.

                                        {
     if (!isApplicable(node)) {
         return;
     }
     if (MapTools::containsKey(assignedResources_, &node)) {
  
         TTAProgram::Move& move = node.move();
         const TerminalFUPort* src = dynamic_cast<const TerminalFUPort*>(&move.source());
         if (src) {
             const TerminalFUPort* src = dynamic_cast<const TerminalFUPort*>(&move.source());
             assert(src);
             SchedulingResource& res = *resourceOf(src->functionUnit());
             const ControlUnit* gcu =
                 dynamic_cast<const ControlUnit*>(&machinePartOf(res));
  
             // not ra read? unassign from fu
             if (gcu == NULL) {
                 OutputFUResource* fuRes = dynamic_cast<OutputFUResource*>(&res);
                 fuRes->unassign(node.cycle(), node);
             }
         } else {
             if (node.isGuardOperation()) {
                 ProgramOperation& gop = node.guardOperation();
                 SchedulingResource& res = *resourceOf(*gop.fuFromOutMove(node));
                 res.unassign(node.cycle(), node);
             }
         }
         // removed from assigned resources also if ra read
         assignedResources_.erase(&node);
     }
 }

References assert, ResourceBroker::assignedResources_, MapTools::containsKey(), MoveNode::cycle(), ProgramOperation::fuFromOutMove(), TTAProgram::TerminalFUPort::functionUnit(), MoveNode::guardOperation(), isApplicable(), MoveNode::isGuardOperation(), ResourceBroker::machinePartOf(), MoveNode::move(), ResourceBroker::resourceOf(), TTAProgram::Move::source(), SchedulingResource::unassign(), and OutputFUResource::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

◆ OutputFUBroker()

◆ ~OutputFUBroker()

Member Function Documentation

◆ allAvailableResources()

◆ assign()

◆ buildResources()

◆ earliestCycle()

◆ isAlreadyAssigned()

◆ isApplicable()

◆ latestCycle()

◆ setupResourceLinks()

◆ unassign()