#include <IUBroker.hh>

Inheritance diagram for IUBroker:

Collaboration diagram for IUBroker:

Classes
struct	less_width
	Functor for sorting result of allAvailable by register width. More...

Public Member Functions
	IUBroker (std::string)

	IUBroker (std::string, SimpleResourceManager *, unsigned int initiationInterval=0)

virtual	~IUBroker ()

bool	isAnyResourceAvailable (int useCycle, 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 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 override

virtual SchedulingResourceSet	allAvailableResources (int, const MoveNode &, 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, MoveNode &, SchedulingResource &, 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 *preassignedBus) const override

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

virtual void	setupResourceLinks (const ResourceMapper &mapper) override

virtual bool	isIUBroker () const override

virtual std::shared_ptr< TTAProgram::TerminalImmediate >	immediateValue (const MoveNode &node) const

virtual int	immediateWriteCycle (const MoveNode &node) const

void	clearOldResources ()

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

virtual	~ResourceBroker ()

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	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
const TTAMachine::Machine *	target_
	Target machine. More...

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

Immediate unit broker.

Definition at line 57 of file IUBroker.hh.

Constructor & Destructor Documentation

◆ IUBroker() [1/2]

IUBroker::IUBroker ( std::string name )

Constructor.

Definition at line 63 of file IUBroker.cc.

                                 :
     ResourceBroker(name),
     target_(NULL),
     rm_(NULL) {
 }

◆ IUBroker() [2/2]

IUBroker::IUBroker	(	std::string	name,
		SimpleResourceManager *	rm,
		unsigned int	initiationInterval = `0`
	)

Constructor.

Definition at line 72 of file IUBroker.cc.

                                          :
     ResourceBroker(name, initiationInterval),
     target_(NULL), rm_(rm) {
 }

◆ ~IUBroker()

IUBroker::~IUBroker ( )

virtual

Destructor.

Definition at line 81 of file IUBroker.cc.

81 {

82 }

Member Function Documentation

◆ allAvailableResources()

SchedulingResourceSet IUBroker::allAvailableResources	(	int	useCycle,
		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

useCycle	Read from immediate register by Node
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 149 of file IUBroker.cc.

                                                        {
  
     int defCycle = useCycle;
     if (immWriteCycle != -1) {
         defCycle = immWriteCycle;
     }
  
     SchedulingResourceSet results;
  
     // pre-split LIMM
     if (node.move().source().isImmediateRegister()) {
         const ImmediateUnit& iu =
             node.move().source().immediateUnit();
         IUResource* iuRes = static_cast<IUResource*>(resourceOf(iu));
         if (iuRes->canAssign(useCycle, node)) {
             results.insert(*iuRes);
         }
         return results;
     }
  
     std::vector<IUResource*> tmpResult;
  
     // RM breaks if LIMM write and use are in same instruction.
     int maxLimmDistance = MAX_LIMM_DISTANCE;
     if (initiationInterval_) {
         maxLimmDistance = std::min(maxLimmDistance, (int)initiationInterval_);
     }
     while (defCycle >= 0 && (useCycle - defCycle) < maxLimmDistance &&
            tmpResult.empty()) {
         ResourceMap::const_iterator resIter = resMap_.begin();
         while (resIter != resMap_.end()) {
             // TODO: why is this dynamic, not static cast?
             IUResource* iuRes = dynamic_cast<IUResource*>((*resIter).second);
             if (immu == NULL || resourceOf(*immu) == (*resIter).second) {
                 if (iuRes->canAssign(defCycle, useCycle, node, immRegIndex)) {
                     TerminalImmediate* tempImm =
                         dynamic_cast<TerminalImmediate*>(
                             node.move().source().copy());
                     const ImmediateUnit& iu =
                         dynamic_cast<const ImmediateUnit&>(
                             machinePartOf(*iuRes));
                     RFPort* port = iu.port(0);
                     TerminalRegister* newSrc = new TerminalRegister(*port, 0);
                     auto imm = std::make_shared<Immediate>(tempImm, newSrc);
                     if (rm_->isTemplateAvailable(defCycle, imm)) {
                         tmpResult.push_back(iuRes);
                     }
                 }
             }
             resIter++;
         }
         sort(tmpResult.begin(), tmpResult.end(), less_width());
         std::vector<IUResource*>::iterator tmpItr = tmpResult.begin();
         while (tmpItr != tmpResult.end()) {
             results.insert(*(*tmpItr));
             tmpItr++;
         }
         if (immWriteCycle != -1) {
             break;
         }
         defCycle--;
     }
     return results;
 }

References IUResource::canAssign(), TTAProgram::Terminal::copy(), TTAProgram::Terminal::immediateUnit(), ResourceBroker::initiationInterval_, SchedulingResourceSet::insert(), TTAProgram::Terminal::isImmediateRegister(), SimpleResourceManager::isTemplateAvailable(), ResourceBroker::machinePartOf(), MAX_LIMM_DISTANCE, MoveNode::move(), TTAMachine::BaseRegisterFile::port(), ResourceBroker::resMap_, ResourceBroker::resourceOf(), rm_, and TTAProgram::Move::source().

Referenced by availableResource(), and isAnyResourceAvailable().

Here is the call graph for this function:

◆ assign()

void IUBroker::assign	(	int	useCycle,
		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.

Parameters

useCycle	Cycle in which immediate register is read by Node
node	MoveNode that reads a register
res	Long immediate register file resource
immWriteCycle	forced def cycle for the immediate. Not forced if -1

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 233 of file IUBroker.cc.

                      {
  
     int defCycle = useCycle;
     if (immWriteCycle != -1) {
         defCycle = immWriteCycle;
     }
  
     IUResource& iuRes = dynamic_cast<IUResource&>(res);
     Move& move = const_cast<MoveNode&>(node).move();
  
     if (hasResource(res)) {
         ImmediateUnit& iu =
             const_cast<ImmediateUnit&>(
                 dynamic_cast<const ImmediateUnit&>(machinePartOf(res)));
  
         // pre-split LIMM
         if (node.move().source().isImmediateRegister()) {
             const ImmediateUnit& iuSrc =
                 node.move().source().immediateUnit();
             assert(&iu == &iuSrc);
             IUResource* iuRes = static_cast<IUResource*>(resourceOf(iu));
             iuRes->assign(useCycle, node);
             assignedResources_.insert(
                 std::pair<const MoveNode*, SchedulingResource*>(&node, iuRes));
  
         } else {
             int index = -1;
             // IURes assign method will set index to the register
             // in IU that was assigned for immediate read
  
             while (defCycle >= 0 && (useCycle - defCycle) < MAX_LIMM_DISTANCE) {
                 if (iuRes.canAssign(defCycle, useCycle, node, immRegIndex)) {
                     TerminalImmediate* tempImm =
                         dynamic_cast<TerminalImmediate*>(
                             node.move().source().copy());
                     const ImmediateUnit& iu =
                         dynamic_cast<const ImmediateUnit&>(machinePartOf(iuRes));
                     RFPort* port = iu.port(0);
                     TerminalRegister* newSrc = new TerminalRegister(*port, 0);
                     auto imm = std::make_shared<Immediate>(tempImm, newSrc);
                     if (rm_->isTemplateAvailable(defCycle, imm)) {
                         break;
                     }
                 }
                 if (immWriteCycle != -1) {
                     std::cerr << "Use cycle: " << useCycle << " imm cycle: "
                               << immWriteCycle << " node: " << node.toString()
                               << std::endl;
                     assert(NULL && "Can't assign forced imm write at cycle");
                 }
                 defCycle--;
             }
         // is index forced?
         if (immRegIndex != -1)
         index = immRegIndex;
             iuRes.assign(defCycle, useCycle, node, index);
  
  
             // temporary, source() has to know some port of IU to
             // be able to identify which IU Move uses.
             // OutputPSocket broker will assign a free port later
             RFPort* port = iu.port(0);
             assignedResources_.insert(
                 std::pair<const MoveNode*, SchedulingResource*>(&node, &iuRes));
             TerminalRegister* newSrc = new TerminalRegister(*port, index);
             move.setSource(newSrc);
         }
     } else {
         string msg = "Broker does not contain given resource.";
         throw InvalidData(__FILE__, __LINE__, __func__, msg);
     }
 }

References __func__, assert, IUResource::assign(), ResourceBroker::assignedResources_, IUResource::canAssign(), TTAProgram::Terminal::copy(), ResourceBroker::hasResource(), TTAProgram::Terminal::immediateUnit(), TTAProgram::Terminal::isImmediateRegister(), SimpleResourceManager::isTemplateAvailable(), ResourceBroker::machinePartOf(), MAX_LIMM_DISTANCE, MoveNode::move(), TTAMachine::BaseRegisterFile::port(), ResourceBroker::resourceOf(), rm_, TTAProgram::Move::setSource(), TTAProgram::Move::source(), and MoveNode::toString().

Here is the call graph for this function:

◆ availableResource()

SchedulingResource & IUBroker::availableResource	(	int	useCycle,
		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 one (any) resource managed by this broker that has a register available for assignment between given definition and use cycles.

Parameters

useCycle	Use cycle.
node	Node.

Returns: One (any) resource managed by this broker that has a register available for assignment between given definition and use cycles.

Reimplemented from ResourceBroker.

Definition at line 122 of file IUBroker.cc.

           {
     try {
         return allAvailableResources(
             useCycle, node, bus, srcFU, dstFU, immWriteCycle, immu, immRegIndex).
         resource(0);
     } catch (const KeyNotFound& e) {
         std::string message = "No immediate register resource available.";
         throw InstanceNotFound(__FILE__, __LINE__, __func__, message);
     }
 }

References __func__, and allAvailableResources().

Here is the call graph for this function:

◆ buildResources()

void IUBroker::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 453 of file IUBroker.cc.

                                                         {
  
     target_ = &target;
     Machine::ImmediateUnitNavigator navi = target.immediateUnitNavigator();
  
     for (int i = 0; i < navi.count(); i++) {
         ImmediateUnit* iu = navi.item(i);
         bool extension = false;
         if (iu->extensionMode() == Machine::ZERO) {
             extension = false;
         } else {
             extension = true;
         }
         IUResource* iuResource =
             new IUResource(
                 target,
                 iu->name(), iu->numberOfRegisters(), iu->width(),
                 iu->latency(), extension, initiationInterval_);
         ResourceBroker::addResource(*iu, iuResource);
     }
 }

References ResourceBroker::addResource(), TTAMachine::Machine::Navigator< ComponentType >::count(), TTAMachine::ImmediateUnit::extensionMode(), TTAMachine::Machine::immediateUnitNavigator(), ResourceBroker::initiationInterval_, TTAMachine::Machine::Navigator< ComponentType >::item(), TTAMachine::ImmediateUnit::latency(), TTAMachine::Component::name(), TTAMachine::BaseRegisterFile::numberOfRegisters(), target_, and TTAMachine::BaseRegisterFile::width().

Here is the call graph for this function:

◆ clearOldResources()

void IUBroker::clearOldResources ( )

Clears bookkeeping which is needed for unassigning previously assigned moves. After this call these cannot be unassigned, but new moves which are assigned after this call can still be unassigned.

Definition at line 598 of file IUBroker.cc.

                             {
     for (ResourceMap::iterator i = resMap_.begin(); i != resMap_.end(); i++) {
         IUResource* iuRes = static_cast<IUResource*>(i->second);
         iuRes->clearOldResources();
     }
 }

References IUResource::clearOldResources(), and ResourceBroker::resMap_.

Referenced by SimpleBrokerDirector::clearOldResources().

Here is the call graph for this function:

◆ earliestCycle()

int IUBroker::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 347 of file IUBroker.cc.

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

References abortWithError.

◆ immediateValue()

std::shared_ptr< TTAProgram::TerminalImmediate > IUBroker::immediateValue ( const MoveNode & node ) const

virtual

Returns a original Immediate value for a node

Parameters

node	Node that was changed to immediate register read

Returns: Terminal representing original source of Move

Definition at line 555 of file IUBroker.cc.

                                                    {
     if (!node.isSourceImmediateRegister()) {
         return NULL;
     }
     if (MapTools::containsKey(assignedResources_, &node)) {
         IUResource* iuRes = dynamic_cast<IUResource*>(
             MapTools::valueForKey<SchedulingResource*>(
                 assignedResources_, &node));
         return iuRes->immediateValue(node);
     }
     throw KeyNotFound(__FILE__, __LINE__, __func__,
         "MoveNode was not assigned Immediate resource.");
 }

References __func__, ResourceBroker::assignedResources_, MapTools::containsKey(), IUResource::immediateValue(), and MoveNode::isSourceImmediateRegister().

Referenced by SimpleBrokerDirector::immediateValue().

Here is the call graph for this function:

◆ immediateWriteCycle()

int IUBroker::immediateWriteCycle ( const MoveNode & node ) const

virtual

Returns a cycle in which the original Immediate value is written into immediate register.

Parameters

node	Node that was changed to immediate register read

Returns: Cycle in which immediate was written into register.

Definition at line 578 of file IUBroker.cc.

                                                         {
     if (!node.isSourceImmediateRegister()) {
         return -1;
     }
     if (MapTools::containsKey(assignedResources_, &node)) {
         IUResource* iuRes = dynamic_cast<IUResource*>(
             MapTools::valueForKey<SchedulingResource*>(
                 assignedResources_, &node));
         return iuRes->immediateWriteCycle(node);
     }
     throw KeyNotFound(__FILE__, __LINE__, __func__,
         "MoveNode was not assigned Immediate resource.");
 }

References __func__, ResourceBroker::assignedResources_, MapTools::containsKey(), IUResource::immediateWriteCycle(), and MoveNode::isSourceImmediateRegister().

Referenced by SimpleBrokerDirector::immediateWriteCycle().

Here is the call graph for this function:

◆ isAlreadyAssigned()

bool IUBroker::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 394 of file IUBroker.cc.

                                                            {
     if (!MapTools::containsKey(assignedResources_, &node)) {
         return false;
     }
     try {
         // Somehow nasty solution, but in correct case should
         // never be throwing exception
         IUResource* iu = dynamic_cast<IUResource*>(
             MapTools::valueForKey<SchedulingResource*>(
             assignedResources_, &node));
         iu->immediateValue(node);
     } catch (const KeyNotFound&) {
         return false;
     }
     return true;
 }

References ResourceBroker::assignedResources_, MapTools::containsKey(), and IUResource::immediateValue().

Here is the call graph for this function:

◆ isAnyResourceAvailable()

bool IUBroker::isAnyResourceAvailable	(	int	useCycle,
		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 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

defCycle	Cycle in which the write to long immediate register is
useCycle	Cycle in which the long immediate register is read by node
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 97 of file IUBroker.cc.

                                                         {
     int resultCount = allAvailableResources(
         useCycle, node, bus, srcFU, dstFU, immWriteCycle, immu, immRegIndex).
     count();
     return (resultCount > 0);
 }

References allAvailableResources().

Here is the call graph for this function:

◆ isApplicable()

bool IUBroker::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 is Immediate read.

Note: this method is called to determine if node needs IU resource as well as by resetAssignments to remove the IU assignment

Implements ResourceBroker.

Definition at line 422 of file IUBroker.cc.

                                                                      {
     if (!node.isMove()) {
         return false;
     }
     if (node.isSourceImmediateRegister()) {
         return true;
     }
     // If node is annotated, it needs to be converted to LIMM,
     // detected in BB scheduler
     if (node.isSourceConstant() && node.move().hasAnnotations(
             TTAProgram::ProgramAnnotation::ANN_REQUIRES_LIMM)) {
         return true;
     }
     if (node.isSourceConstant() &&
         !rm_->canTransportImmediate(node, preassignedBus)) {
         return true;
     }
     return false;
 }

References TTAProgram::ProgramAnnotation::ANN_REQUIRES_LIMM, SimpleResourceManager::canTransportImmediate(), TTAProgram::AnnotatedInstructionElement::hasAnnotations(), MoveNode::isMove(), MoveNode::isSourceConstant(), MoveNode::isSourceImmediateRegister(), MoveNode::move(), and rm_.

Here is the call graph for this function:

◆ isIUBroker()

bool IUBroker::isIUBroker ( ) const

overridevirtual

Return true always.

Returns: True always.

Reimplemented from ResourceBroker.

Definition at line 543 of file IUBroker.cc.

                            {
     return true;
 }

◆ latestCycle()

int IUBroker::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 370 of file IUBroker.cc.

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

References abortWithError.

◆ setupResourceLinks()

void IUBroker::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 484 of file IUBroker.cc.

                                                          {
  
     setResourceMapper(mapper);
  
     for (ResourceMap::iterator resIter = resMap_.begin();
          resIter != resMap_.end(); resIter++) {
  
         const ImmediateUnit* iu =
             dynamic_cast<const ImmediateUnit*>((*resIter).first);
  
         SchedulingResource* iuResource = (*resIter).second;
         for (int i = 0; i < iu->portCount(); i++) {
             Port* port = iu->port(i);
             if (port->outputSocket() != NULL) {
                 try {
                     SchedulingResource& relatedRes =
                         mapper.resourceOf(*port->outputSocket());
                     iuResource->addToRelatedGroup(0, relatedRes);
                 } catch (const KeyNotFound& e) {
                     std::string msg = "IUBroker: finding ";
                     msg += " resource for Socket ";
                     msg += " failed with error: ";
                     msg += e.errorMessageStack();
                     throw KeyNotFound(
                         __FILE__, __LINE__, __func__, msg);
                 }
             }
         }
  
         Machine::InstructionTemplateNavigator navi =
             target_->instructionTemplateNavigator();
  
         for (int i = 0; i < navi.count(); i++) {
             InstructionTemplate* itemplate = navi.item(i);
             if (itemplate->isOneOfDestinations(*iu)) {
                 try {
                     SchedulingResource& relatedRes =
                         mapper.resourceOf(*itemplate);
                     iuResource->addToRelatedGroup(1, relatedRes);
                 } catch (const KeyNotFound& e) {
                     std::string msg = "IUBroker: finding ";
                     msg += " resource for Template ";
                     msg += " failed with error: ";
                     msg += e.errorMessageStack();
                     throw KeyNotFound(
                         __FILE__, __LINE__, __func__, msg);
                 }
             }
         }
     }
     // todo: dependent register resources?
 }

References __func__, SchedulingResource::addToRelatedGroup(), TTAMachine::Machine::Navigator< ComponentType >::count(), Exception::errorMessageStack(), TTAMachine::Machine::instructionTemplateNavigator(), TTAMachine::InstructionTemplate::isOneOfDestinations(), TTAMachine::Machine::Navigator< ComponentType >::item(), TTAMachine::Port::outputSocket(), TTAMachine::BaseRegisterFile::port(), TTAMachine::Unit::portCount(), ResourceBroker::resMap_, ResourceMapper::resourceOf(), ResourceBroker::setResourceMapper(), and target_.

Here is the call graph for this function:

◆ unassign()

void IUBroker::unassign ( MoveNode & node )

overridevirtual

Free the Immediate register and set MoveNode source back to TerminalImmediate constant.

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.

Note: The ImmediateResource keeps a copy of original source terminal and will restore it during unassignment.

Implements ResourceBroker.

Definition at line 321 of file IUBroker.cc.

                                  {
     if (!MapTools::containsKey(assignedResources_, &node)) {
         TCEString msg = "Trying to unassign Long Immediate register ";
         msg += "that was not assigned previously: " + node.toString();
         abortWithError(msg);
         return;
     }
     IUResource* iuRes = dynamic_cast<IUResource*>(
         MapTools::valueForKey<SchedulingResource*>(
             assignedResources_, &node));
     iuRes->unassign(node.cycle(), node);
     assignedResources_.erase(&node);
 }

References abortWithError, ResourceBroker::assignedResources_, MapTools::containsKey(), MoveNode::cycle(), MoveNode::toString(), and IUResource::unassign().

Here is the call graph for this function:

Member Data Documentation

◆ rm_

SimpleResourceManager* IUBroker::rm_

private

Definition at line 136 of file IUBroker.hh.

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

◆ target_

const TTAMachine::Machine* IUBroker::target_

private

Target machine.

Definition at line 127 of file IUBroker.hh.

Referenced by buildResources(), and setupResourceLinks().

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

Classes

Public Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ IUBroker() [1/2]

◆ IUBroker() [2/2]

◆ ~IUBroker()

Member Function Documentation

◆ allAvailableResources()

◆ assign()

◆ availableResource()

◆ buildResources()

◆ clearOldResources()

◆ earliestCycle()

◆ immediateValue()

◆ immediateWriteCycle()

◆ isAlreadyAssigned()

◆ isAnyResourceAvailable()

◆ isApplicable()

◆ isIUBroker()

◆ latestCycle()

◆ setupResourceLinks()

◆ unassign()

Member Data Documentation

◆ rm_

◆ target_