#include <PendingAssignment.hh>

Collaboration diagram for PendingAssignment:

Public Member Functions
	PendingAssignment (ResourceBroker &broker)

virtual	~PendingAssignment ()

ResourceBroker &	broker ()

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

bool	isAssignmentPossible ()

void	tryNext ()

void	undoAssignment ()

void	forget ()

void	clear ()

SchedulingResource &	resource (int index)

int	lastTriedAssignment () const

Private Attributes
ResourceBroker &	broker_
	Corresponding resource broker. More...

int	cycle_

MoveNode *	node_

const TTAMachine::Bus *	bus_

const TTAMachine::FunctionUnit *	srcFU_

const TTAMachine::FunctionUnit *	dstFU_

int	immWriteCycle_

bool	assignmentTried_

SchedulingResourceSet	availableResources_

int	lastTriedAssignment_

const TTAMachine::ImmediateUnit *	immu_

int	immRegIndex_

Detailed Description

Definition at line 48 of file PendingAssignment.hh.

Constructor & Destructor Documentation

◆ PendingAssignment()

PendingAssignment::PendingAssignment ( ResourceBroker & broker )

Constructor.

Definition at line 44 of file PendingAssignment.cc.

                                                           :
     broker_(broker), cycle_(-1), node_(NULL), assignmentTried_(false),
     lastTriedAssignment_(-1) {
 }

◆ ~PendingAssignment()

PendingAssignment::~PendingAssignment ( )

virtual

Destructor.

Definition at line 52 of file PendingAssignment.cc.

52 {

53 }

Member Function Documentation

◆ broker()

ResourceBroker & PendingAssignment::broker ( )

Return the broker of this pending assignment.

Returns: The broker of this pending assignment.

Definition at line 61 of file PendingAssignment.cc.

                           {
     return broker_;
 }

References broker_.

Referenced by AssignmentPlan::backtrack(), AssignmentPlan::isTestedAssignmentPossible(), and AssignmentPlan::tryNextAssignment().

◆ clear()

void PendingAssignment::clear ( )

Clears the pending assignment.

Does not unassign anything.

Definition at line 177 of file PendingAssignment.cc.

                          {
     cycle_ = -1;
     node_ = NULL;
     immu_ = NULL;
     immWriteCycle_ = -1;
     immRegIndex_ = -1;
  
     assignmentTried_ = false;
     lastTriedAssignment_ = -1;
     availableResources_.clear();
     bus_ = NULL;
 }

References assignmentTried_, availableResources_, bus_, SchedulingResourceSet::clear(), cycle_, immRegIndex_, immu_, immWriteCycle_, lastTriedAssignment_, and node_.

Here is the call graph for this function:

◆ forget()

void PendingAssignment::forget ( )

Clear out the record of the possible resource assignments of the current broker that have been already tried.

If one of the possible resources is still assigned to the node, unassign it.

Definition at line 164 of file PendingAssignment.cc.

                           {
     if (broker_.isAlreadyAssigned(cycle_, *node_, bus_)) {
         broker_.unassign(*node_);
     }
     lastTriedAssignment_ = -1;
 }

References broker_, bus_, cycle_, ResourceBroker::isAlreadyAssigned(), lastTriedAssignment_, node_, and ResourceBroker::unassign().

Referenced by AssignmentPlan::backtrack().

Here is the call graph for this function:

◆ isAssignmentPossible()

bool PendingAssignment::isAssignmentPossible ( )

Return true if, for the currently applied assignments, there exists at least one tentative assignment which has not been tried yet.

Returns: True if, for the currently applied assignments, there exists at least one tentative assignment which has not been tried yet.

Definition at line 99 of file PendingAssignment.cc.

                                         {
     if (lastTriedAssignment_ == -1) {
         availableResources_ = broker_.allAvailableResources(
         cycle_, *node_, bus_, srcFU_, dstFU_, immWriteCycle_, immu_,
         immRegIndex_);
         // Sorts candidate set of resources by their use count or name if
         // the use counts are identical
         availableResources_.sort();
     }
     return lastTriedAssignment_ < availableResources_.count() - 1;
 }

References ResourceBroker::allAvailableResources(), availableResources_, broker_, bus_, SchedulingResourceSet::count(), cycle_, dstFU_, immRegIndex_, immu_, immWriteCycle_, lastTriedAssignment_, node_, SchedulingResourceSet::sort(), and srcFU_.

Here is the call graph for this function:

◆ lastTriedAssignment()

int PendingAssignment::lastTriedAssignment ( ) const

inline

Definition at line 68 of file PendingAssignment.hh.

68 { return lastTriedAssignment_; }

References lastTriedAssignment_.

Referenced by AssignmentPlan::isTestedAssignmentPossible().

◆ resource()

SchedulingResource& PendingAssignment::resource ( int index )

inline

Definition at line 66 of file PendingAssignment.hh.

66 {

67 return availableResources_.resource(index); }

References availableResources_, and SchedulingResourceSet::resource().

Referenced by AssignmentPlan::isTestedAssignmentPossible().

Here is the call graph for this function:

◆ setRequest()

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

Record the input node to which resources have to be assigned or allocated, and the cycle in which the node should be placed.

Parameters

cycle	Cycle.
node	Node.

Definition at line 73 of file PendingAssignment.cc.

                                                {
     cycle_ = cycle;
     node_ = &node;
     bus_ = bus;
     srcFU_ = srcFU;
     dstFU_ = dstFU;
     immWriteCycle_ = immWriteCycle;
     immu_ = immu;
     immRegIndex_ = immRegIndex;
     lastTriedAssignment_ = -1;
 }

References bus_, cycle_, dstFU_, immRegIndex_, immu_, immWriteCycle_, lastTriedAssignment_, node_, and srcFU_.

◆ tryNext()

void PendingAssignment::tryNext ( )

Try to assign the next possible assignment found by current broker.

Exceptions

ModuleRunTimeError If this PendingAssignment has run out of possible assignments.

Definition at line 119 of file PendingAssignment.cc.

                            {
  
     lastTriedAssignment_ += 1;
  
     if (availableResources_.count() == 0 ||
         lastTriedAssignment_ >= availableResources_.count()) {
         string msg = "Ran out of possible assignments!";
         throw ModuleRunTimeError(__FILE__, __LINE__, __func__, msg);
     }
  
     broker_.assign(
         cycle_, *node_, availableResources_.resource(lastTriedAssignment_),
         immWriteCycle_, immRegIndex_);
     assignmentTried_ = true;
 }

References __func__, ResourceBroker::assign(), assignmentTried_, availableResources_, broker_, SchedulingResourceSet::count(), cycle_, immRegIndex_, immWriteCycle_, lastTriedAssignment_, node_, and SchedulingResourceSet::resource().

Referenced by AssignmentPlan::tryNextAssignment().

Here is the call graph for this function:

◆ undoAssignment()

void PendingAssignment::undoAssignment ( )

Unassign the resource of this pending assignment currently assigned to the node.

Last tried assignment is remembered.

Exceptions

ModuleRunTimeError If no resource in the set of resources of this pending assignment is currently assigned to the node.

Definition at line 146 of file PendingAssignment.cc.

                                   {
     if (broker_.isAlreadyAssigned(cycle_, *node_, bus_)) {
         broker_.unassign(*node_);
     } else {
         string msg = "No resource in the set of resources of this pending"
             "assignment was assigned to the given node!";
         throw ModuleRunTimeError(__FILE__, __LINE__, __func__, msg);
     }
 }