OpenASIP  2.0
Public Member Functions | Private Attributes | List of all members
AssignmentPlan Class Reference

#include <AssignmentPlan.hh>

Collaboration diagram for AssignmentPlan:
Collaboration graph

Public Member Functions

 AssignmentPlan ()
 
virtual ~AssignmentPlan ()
 
void insertBroker (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)
 
ResourceBrokerfirstBroker ()
 
ResourceBrokernextBroker (ResourceBroker &pos)
 
ResourceBrokerlastBroker ()
 
ResourceBrokercurrentBroker ()
 
void advance ()
 
void backtrack ()
 
void tryNextAssignment ()
 
bool isTestedAssignmentPossible ()
 
void resetAssignments ()
 
void resetAssignments (MoveNode &node)
 
int brokerCount () const
 
ResourceBrokerbroker (int index) const
 
void clear ()
 
bool tryCachedAssignment (MoveNode &node, int cycle, const TTAMachine::Bus *bus, const TTAMachine::FunctionUnit *srcFU, const TTAMachine::FunctionUnit *dstFU, int immWriteCycle, const TTAMachine::ImmediateUnit *immu, int immRegIndex)
 
void clearCache ()
 

Private Attributes

const TTAMachine::Busbus_
 
const TTAMachine::FunctionUnitsrcFU_
 
const TTAMachine::FunctionUnitdstFU_
 
int immWriteCycle_
 
const TTAMachine::ImmediateUnitimmu_
 
int immRegIndex_
 
std::vector< PendingAssignment * > assignments_
 Sequence of pending assignments. More...
 
std::vector< PendingAssignment * > applicableAssignments_
 Sequence of applicable pending assignments. More...
 
std::vector< ResourceBroker * > brokers_
 Sequence of resource brokers. More...
 
MoveNodenode_
 Move of current resource assignment request. More...
 
int cycle_
 Cycle in which current node should be placed. More...
 
int currentBroker_
 Current broker. More...
 
bool resourceFound_
 True if a valid resource of current broker has been assigned. More...
 
std::vector< std::pair< ResourceBroker *, SchedulingResource * > > lastTestedWorkingAssignment_
 cache. More...
 
MoveNodelastTriedNode_
 
int lastTriedCycle_
 

Detailed Description

Keeps the order in which single resource-specific brokers are invoked to perform their bit of the allocation or assignment. Also records the current state of tentative and potential assignments for each type of resource.

Definition at line 56 of file AssignmentPlan.hh.

Constructor & Destructor Documentation

◆ AssignmentPlan()

AssignmentPlan::AssignmentPlan ( )

Constructor.

Definition at line 50 of file AssignmentPlan.cc.

50  :
51  node_(NULL), cycle_(0), currentBroker_(0), resourceFound_(false),
52  lastTriedNode_(NULL), lastTriedCycle_(-1) {
53 }

◆ ~AssignmentPlan()

AssignmentPlan::~AssignmentPlan ( )
virtual

Destructor.

Definition at line 58 of file AssignmentPlan.cc.

References assignments_, and AssocTools::deleteAllItems().

Here is the call graph for this function:

Member Function Documentation

◆ advance()

void AssignmentPlan::advance ( )

Move to the next resource broker in the sequence.

Definition at line 191 of file AssignmentPlan.cc.

191  {
192  if (resourceFound_) {
193  currentBroker_++;
194  } else {
195  string msg = "Tried to advance before a valid assignment was made!";
196  throw ModuleRunTimeError(__FILE__, __LINE__, __func__, msg);
197  }
198  if (currentBroker_ >= static_cast<int>(applicableAssignments_.size())) {
199  string msg = "Advanced beyond last resource broker!";
200  throw ModuleRunTimeError(__FILE__, __LINE__, __func__, msg);
201  }
202 }

References __func__, applicableAssignments_, currentBroker_, and resourceFound_.

Referenced by SimpleBrokerDirector::assign(), and SimpleBrokerDirector::canAssign().

◆ backtrack()

void AssignmentPlan::backtrack ( )

Unassign (if needed) the resource of current broker from the node and then move to previous resource broker in the sequence.

The pending assignments of the current node are forgotten.

Definition at line 211 of file AssignmentPlan.cc.

211  {
212  // forget assignment history and assignments for current broker
214  assignment->forget();
215  if (assignment->broker().isAlreadyAssigned(cycle_, *node_, bus_)) {
216  assignment->undoAssignment();
217  }
218  currentBroker_--;
219  if (currentBroker_ < 0) {
220  string msg = "Backtracked beyond first resource broker!";
221  throw ModuleRunTimeError(__FILE__, __LINE__, __func__, msg);
222  } else {
223  // undo possible assignments for broker we backtracked to
225  if (assignment->broker().isAlreadyAssigned(cycle_, *node_, bus_)) {
226  assignment->undoAssignment();
227  }
228  }
229 }

References __func__, applicableAssignments_, PendingAssignment::broker(), bus_, currentBroker_, cycle_, PendingAssignment::forget(), ResourceBroker::isAlreadyAssigned(), node_, and PendingAssignment::undoAssignment().

Referenced by SimpleBrokerDirector::assign(), and SimpleBrokerDirector::canAssign().

Here is the call graph for this function:

◆ broker()

ResourceBroker & AssignmentPlan::broker ( int  index) const

Return the broker in the given index.

Parameters
indexIndex of broker.
Returns
The broker in the given index.
Exceptions
OutOfRangeif index is out of bounds.

Definition at line 436 of file AssignmentPlan.cc.

436  {
437  if (index < 0 || index >= static_cast<int>(brokers_.size())) {
438  string msg = "Broker index out of range.";
439  throw OutOfRange(__FILE__, __LINE__, __func__, msg);
440  } else {
441  return *brokers_[index];
442  }
443 }

References __func__, and brokers_.

Referenced by SimpleBrokerDirector::busBroker(), SimpleBrokerDirector::executionPipelineBroker(), SimpleBrokerDirector::immediateUnitBroker(), insertBroker(), SimpleBrokerDirector::instructionTemplateBroker(), nextBroker(), setRequest(), and tryCachedAssignment().

◆ brokerCount()

int AssignmentPlan::brokerCount ( ) const

Return the number of brokers in assignment plan.

Returns
The number of brokers in assignment plan.

Definition at line 424 of file AssignmentPlan.cc.

424  {
425  return brokers_.size();
426 }

References brokers_.

Referenced by SimpleBrokerDirector::busBroker(), SimpleBrokerDirector::executionPipelineBroker(), SimpleBrokerDirector::immediateUnitBroker(), and SimpleBrokerDirector::instructionTemplateBroker().

◆ clear()

void AssignmentPlan::clear ( )

Definition at line 446 of file AssignmentPlan.cc.

446  {
447  node_= NULL;
448  cycle_ = 0;
449  currentBroker_ = 0;
450  resourceFound_ = false;
451  for (size_t i = 0; i < assignments_.size(); i++) {
452  assignments_[i]->clear();
453  }
454  bus_ = NULL;
455  srcFU_ = NULL;
456  dstFU_ = NULL;
457  immWriteCycle_ = -1;
458  immu_ = NULL;
459  immRegIndex_ = -1;
460  clearCache();
461  applicableAssignments_.clear();
462 }

References applicableAssignments_, assignments_, bus_, clearCache(), currentBroker_, cycle_, dstFU_, immRegIndex_, immu_, immWriteCycle_, node_, resourceFound_, and srcFU_.

Referenced by SimpleBrokerDirector::clear().

Here is the call graph for this function:

◆ clearCache()

void AssignmentPlan::clearCache ( )

Definition at line 464 of file AssignmentPlan.cc.

464  {
466  lastTriedCycle_ = -1;
467  lastTriedNode_ = NULL;
468 }

References lastTestedWorkingAssignment_, lastTriedCycle_, and lastTriedNode_.

Referenced by clear(), tryCachedAssignment(), and SimpleBrokerDirector::unassign().

◆ currentBroker()

ResourceBroker & AssignmentPlan::currentBroker ( )

Return the current broker, that is, the broker whose resources are being evaluated during an assignment process.

Returns
The current broker.

Definition at line 179 of file AssignmentPlan.cc.

179  {
180  if (applicableAssignments_.empty()) {
181  string msg = "No applicable brokers found for assignment!";
182  throw ModuleRunTimeError(__FILE__, __LINE__, __func__, msg);
183  }
184  return applicableAssignments_[currentBroker_]->broker();
185 }

References __func__, applicableAssignments_, and currentBroker_.

Referenced by SimpleBrokerDirector::assign(), SimpleBrokerDirector::canAssign(), and isTestedAssignmentPossible().

◆ firstBroker()

ResourceBroker & AssignmentPlan::firstBroker ( )

Return the first broker to be evaluated during an assignment process.

Returns
The first broker to be evaluated during an assignment process.

Definition at line 130 of file AssignmentPlan.cc.

130  {
131  if (applicableAssignments_.empty()) {
132  string msg = "No applicable brokers found for assignment!";
133  throw ModuleRunTimeError(__FILE__, __LINE__, __func__, msg);
134  }
135  return applicableAssignments_[0]->broker();
136 }

References __func__, and applicableAssignments_.

Referenced by SimpleBrokerDirector::assign(), and SimpleBrokerDirector::canAssign().

◆ insertBroker()

void AssignmentPlan::insertBroker ( ResourceBroker broker)

Insert a resource broker in the sequence of brokers.

Parameters
brokerResource broker to be inserted.

Definition at line 68 of file AssignmentPlan.cc.

68  {
69  assignments_.push_back(new PendingAssignment(broker));
70  brokers_.push_back(&broker);
71 }

References assignments_, broker(), and brokers_.

Referenced by SimpleResourceManager::buildResourceModel().

Here is the call graph for this function:

◆ isTestedAssignmentPossible()

bool AssignmentPlan::isTestedAssignmentPossible ( )

Return true if at least one tentative assignment is possible with the current broker and the tentative assignments currently applied from the preceding resource brokers.

There are two reasons why no possible assignments are left with the current broker: because all pending assignments have been tried, or because no valid assignment at all is possible.

If the assignment being tested was last of the assignments in the plan (which means move can be assigned completely) stores the information about used resources into the last working assignment cache.

Returns
True if at least one tentative assignment is possible with the current broker

Definition at line 263 of file AssignmentPlan.cc.

263  {
264  bool possible =
265  applicableAssignments_[currentBroker_]->isAssignmentPossible();
266  if (possible) {
267  // is this the last broker?
268  if (currentBroker_ == (int)(applicableAssignments_.size())-1) {
269  // add this to the cache.
270  // first clear the cache.
272  // then set the cache for this assignment.
275  for (unsigned int i = 0; i < applicableAssignments_.size()-1;
276  i++) {
279  std::pair<ResourceBroker*, SchedulingResource*>(
280  &pa.broker(),
281  &pa.resource(pa.lastTriedAssignment())));
282  }
283  // Last one need to be handled separately because
284  // tryNext has not increased lastTriedAssignment.
285  if (!applicableAssignments_.empty()) {
287  applicableAssignments_.size()-1];
289  std::pair<ResourceBroker*, SchedulingResource*>(
290  &pa.broker(),
291  &pa.resource(pa.lastTriedAssignment()+1)));
292  }
293  }
294  } else {
295  debugLogRM("No applicable assignments at all:");
296  debugLogRM(currentBroker().brokerName());
297  }
298  return possible;
299 }

References applicableAssignments_, PendingAssignment::broker(), currentBroker(), currentBroker_, cycle_, debugLogRM, lastTestedWorkingAssignment_, PendingAssignment::lastTriedAssignment(), lastTriedCycle_, lastTriedNode_, node_, and PendingAssignment::resource().

Referenced by SimpleBrokerDirector::assign(), and SimpleBrokerDirector::canAssign().

Here is the call graph for this function:

◆ lastBroker()

ResourceBroker & AssignmentPlan::lastBroker ( )

Return the last broker to be evaluated during an assignment process.

Returns
The last broker to be evaluated during an assignment process.

Definition at line 164 of file AssignmentPlan.cc.

164  {
165  if (applicableAssignments_.empty()) {
166  string msg = "No applicable brokers found for assignment!";
167  throw ModuleRunTimeError(__FILE__, __LINE__, __func__, msg);
168  }
169  return applicableAssignments_[applicableAssignments_.size() - 1]->broker();
170 }

References __func__, and applicableAssignments_.

Referenced by SimpleBrokerDirector::assign(), and SimpleBrokerDirector::canAssign().

◆ nextBroker()

ResourceBroker & AssignmentPlan::nextBroker ( ResourceBroker pos)

Definition at line 139 of file AssignmentPlan.cc.

139  {
140 
141  if (applicableAssignments_.empty()) {
142  string msg = "No applicable brokers found for assignment!";
143  throw ModuleRunTimeError(__FILE__, __LINE__, __func__, msg);
144  }
145 
146  unsigned int i = 0;
147  while (i < applicableAssignments_.size() - 1) {
148  if (&applicableAssignments_[i]->broker() == &pos) {
149  return applicableAssignments_[++i]->broker();
150  }
151  i++;
152  }
153 
154  string msg = "Given broker not found!";
155  throw ModuleRunTimeError(__FILE__, __LINE__, __func__, msg);
156 }

References __func__, applicableAssignments_, and broker().

Here is the call graph for this function:

◆ resetAssignments() [1/2]

void AssignmentPlan::resetAssignments ( )

Unassign as needed all the resources tentatively assigned by all brokers.

Reset the current broker position to the first one.

Definition at line 384 of file AssignmentPlan.cc.

384  {
385  for (unsigned int i = 0; i < applicableAssignments_.size(); i++) {
386  applicableAssignments_[i]->forget();
387  }
388  currentBroker_ = 0;
389  node_->unsetCycle();
390  bus_ = NULL;
391 }

References applicableAssignments_, bus_, currentBroker_, node_, and MoveNode::unsetCycle().

Referenced by SimpleBrokerDirector::canAssign(), and SimpleBrokerDirector::unassign().

Here is the call graph for this function:

◆ resetAssignments() [2/2]

void AssignmentPlan::resetAssignments ( MoveNode node)

Unassign as needed all the resources tentatively assigned to the given node.

Given node needs to be placed on a cycle.

Parameters
nodeNode to unassign.
Exceptions
InvalidDataIf node is not placed on a cycle.

Definition at line 403 of file AssignmentPlan.cc.

403  {
404  if (!node.isPlaced()) {
405  string msg = "Node is not placed in a cycle.";
406  throw InvalidData(__FILE__, __LINE__, __func__, msg);
407  }
408  bus_ = &node.move().bus();
409  for (unsigned int i = 0; i < brokers_.size(); i++) {
410  if (brokers_[i]->isApplicable(node, bus_)) {
411  brokers_[i]->unassign(node);
412  }
413  }
414  node.unsetCycle();
415  bus_ = NULL;
416 }

References __func__, brokers_, TTAProgram::Move::bus(), bus_, MoveNode::isPlaced(), MoveNode::move(), and MoveNode::unsetCycle().

Here is the call graph for this function:

◆ setRequest()

void AssignmentPlan::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
nodeThe node of current assignment request.
cycleThe cycle in which the node should be placed.

Definition at line 81 of file AssignmentPlan.cc.

87  {
88 
89  if (node.isPlaced() && node.cycle() != cycle) {
90  TCEString msg = "Node: " + node.toString();
91  msg << "already placed on different cycle, cur cycle: " << cycle;
92  throw ModuleRunTimeError(__FILE__, __LINE__, __func__, msg);
93  }
94 
95  bus_ = bus;
96  srcFU_ = srcFU;
97  dstFU_ = dstFU;
98  immWriteCycle_ = immWriteCycle;
99  immu_ = immu;
100  immRegIndex_ = immRegIndex;
101 
102  currentBroker_ = 0;
103  node.setCycle(cycle);
104 
105  cycle_ = cycle;
106  node_ = &node;
107 
108  // optimise broker sequence by disabling not applicable brokers
109  applicableAssignments_.clear();
110  for (unsigned int i = 0; i < assignments_.size(); i++) {
111  if (assignments_[i]->broker().isApplicable(node, bus)) {
112  assignments_[i]->setRequest(
113  cycle, node, bus_, srcFU_, dstFU_, immWriteCycle_, immu_,
114  immRegIndex_);
115  applicableAssignments_.push_back(assignments_[i]);
116  }
117  }
118  if (applicableAssignments_.empty()) {
119  string msg = "No applicable brokers found for assignment!";
120  throw ModuleRunTimeError(__FILE__, __LINE__, __func__, msg);
121  }
122 }

References __func__, applicableAssignments_, assignments_, broker(), bus_, currentBroker_, MoveNode::cycle(), cycle_, dstFU_, immRegIndex_, immu_, immWriteCycle_, MoveNode::isPlaced(), node_, MoveNode::setCycle(), srcFU_, and MoveNode::toString().

Referenced by SimpleBrokerDirector::assign(), and SimpleBrokerDirector::canAssign().

Here is the call graph for this function:

◆ tryCachedAssignment()

bool AssignmentPlan::tryCachedAssignment ( MoveNode node,
int  cycle,
const TTAMachine::Bus bus,
const TTAMachine::FunctionUnit srcFU,
const TTAMachine::FunctionUnit dstFU,
int  immWriteCycle,
const TTAMachine::ImmediateUnit immu,
int  immRegIndex 
)

Tries to assign with same resources that which previous canassign succeeded.

If cannot assign with these resources, clear the information of previous successfull canassign and return false. If succeeds, the node is assigned.

Definition at line 310 of file AssignmentPlan.cc.

316  {
317  // is the cache valid for this node?
318  if (lastTriedNode_ != &node ||
319  lastTriedCycle_ != cycle ||
320  immRegIndex_ != immRegIndex ||
321  immu != immu_ ||
322  immWriteCycle_ != immWriteCycle ||
323  srcFU_ != srcFU ||
324  dstFU_ != dstFU ||
326  clearCache();
327  return false;
328  }
329 
330  // test that same brokers are applicable for both cached and current.
331  // may change in case of bypassing.
332  for (size_t j = 0, i = 0; j < brokers_.size(); j++) {
334  if (broker->isApplicable(node, bus)) {
335  if (i >= lastTestedWorkingAssignment_.size() ||
336  lastTestedWorkingAssignment_[i].first != broker) {
337  clearCache();
338  return false;
339  }
340  i++;
341  } else {
342  // if not applicable, must not found in the cached brokers.
343  if (i < lastTestedWorkingAssignment_.size() &&
344  lastTestedWorkingAssignment_[i].first == broker) {
345  clearCache();
346  return false;
347  }
348  }
349  }
350  node.setCycle(cycle);
351 
352  for (int i = 0; i < (int)lastTestedWorkingAssignment_.size(); i++) {
353  std::pair<ResourceBroker*, SchedulingResource*>& ca =
355  if (!ca.first->isAvailable(
356  *ca.second, node, cycle, bus, srcFU, dstFU, immWriteCycle,
357  immu, immRegIndex)) {
358  // failed. backtrack all previous brokers.
359  // unassign, clear cache and return false.
360  for (i--; i >= 0; i--) {
361  std::pair<ResourceBroker*, SchedulingResource*>& ca =
363  ca.first->unassign(node);
364  }
365  node.unsetCycle();
366  clearCache();
367  return false;
368  } else {
369  // can assign. do the assign.
370  ca.first->assign(cycle, node, *ca.second, immWriteCycle, immRegIndex);
371  }
372  }
373  // everything succeeded. clear cache(state of rm changed) and return true.
374  clearCache();
375  return true;
376 }

References broker(), brokers_, clearCache(), dstFU_, immRegIndex_, immu_, immWriteCycle_, ResourceBroker::isApplicable(), lastTestedWorkingAssignment_, lastTriedCycle_, lastTriedNode_, MoveNode::setCycle(), srcFU_, and MoveNode::unsetCycle().

Referenced by SimpleBrokerDirector::assign().

Here is the call graph for this function:

◆ tryNextAssignment()

void AssignmentPlan::tryNextAssignment ( )

Unassign (if needed) the resource of current broker from the node and then assign the next resource from the same list of pending assignments.

Definition at line 237 of file AssignmentPlan.cc.

237  {
239  if (assignment->broker().isAlreadyAssigned(cycle_, *node_, bus_)) {
240  assignment->undoAssignment();
241  }
242  assignment->tryNext();
243  resourceFound_ = true;
244 }

References applicableAssignments_, PendingAssignment::broker(), bus_, currentBroker_, cycle_, ResourceBroker::isAlreadyAssigned(), node_, resourceFound_, PendingAssignment::tryNext(), and PendingAssignment::undoAssignment().

Referenced by SimpleBrokerDirector::assign(), and SimpleBrokerDirector::canAssign().

Here is the call graph for this function:

Member Data Documentation

◆ applicableAssignments_

std::vector<PendingAssignment*> AssignmentPlan::applicableAssignments_
private

◆ assignments_

std::vector<PendingAssignment*> AssignmentPlan::assignments_
private

Sequence of pending assignments.

Definition at line 102 of file AssignmentPlan.hh.

Referenced by clear(), insertBroker(), setRequest(), and ~AssignmentPlan().

◆ brokers_

std::vector<ResourceBroker*> AssignmentPlan::brokers_
private

Sequence of resource brokers.

Definition at line 106 of file AssignmentPlan.hh.

Referenced by broker(), brokerCount(), insertBroker(), resetAssignments(), and tryCachedAssignment().

◆ bus_

const TTAMachine::Bus* AssignmentPlan::bus_
private

Definition at line 94 of file AssignmentPlan.hh.

Referenced by backtrack(), clear(), resetAssignments(), setRequest(), and tryNextAssignment().

◆ currentBroker_

int AssignmentPlan::currentBroker_
private

◆ cycle_

int AssignmentPlan::cycle_
private

Cycle in which current node should be placed.

Definition at line 110 of file AssignmentPlan.hh.

Referenced by backtrack(), clear(), isTestedAssignmentPossible(), setRequest(), and tryNextAssignment().

◆ dstFU_

const TTAMachine::FunctionUnit* AssignmentPlan::dstFU_
private

Definition at line 96 of file AssignmentPlan.hh.

Referenced by clear(), setRequest(), and tryCachedAssignment().

◆ immRegIndex_

int AssignmentPlan::immRegIndex_
private

Definition at line 99 of file AssignmentPlan.hh.

Referenced by clear(), setRequest(), and tryCachedAssignment().

◆ immu_

const TTAMachine::ImmediateUnit* AssignmentPlan::immu_
private

Definition at line 98 of file AssignmentPlan.hh.

Referenced by clear(), setRequest(), and tryCachedAssignment().

◆ immWriteCycle_

int AssignmentPlan::immWriteCycle_
private

Definition at line 97 of file AssignmentPlan.hh.

Referenced by clear(), setRequest(), and tryCachedAssignment().

◆ lastTestedWorkingAssignment_

std::vector<std::pair<ResourceBroker*, SchedulingResource*> > AssignmentPlan::lastTestedWorkingAssignment_
private

cache.

Definition at line 118 of file AssignmentPlan.hh.

Referenced by clearCache(), isTestedAssignmentPossible(), and tryCachedAssignment().

◆ lastTriedCycle_

int AssignmentPlan::lastTriedCycle_
private

Definition at line 120 of file AssignmentPlan.hh.

Referenced by clearCache(), isTestedAssignmentPossible(), and tryCachedAssignment().

◆ lastTriedNode_

MoveNode* AssignmentPlan::lastTriedNode_
private

Definition at line 119 of file AssignmentPlan.hh.

Referenced by clearCache(), isTestedAssignmentPossible(), and tryCachedAssignment().

◆ node_

MoveNode* AssignmentPlan::node_
private

Move of current resource assignment request.

Definition at line 108 of file AssignmentPlan.hh.

Referenced by backtrack(), clear(), isTestedAssignmentPossible(), resetAssignments(), setRequest(), and tryNextAssignment().

◆ resourceFound_

bool AssignmentPlan::resourceFound_
private

True if a valid resource of current broker has been assigned.

Definition at line 114 of file AssignmentPlan.hh.

Referenced by advance(), clear(), and tryNextAssignment().

◆ srcFU_

const TTAMachine::FunctionUnit* AssignmentPlan::srcFU_
private

Definition at line 95 of file AssignmentPlan.hh.

Referenced by clear(), setRequest(), and tryCachedAssignment().


The documentation for this class was generated from the following files:
ResourceBroker::isAlreadyAssigned
virtual bool isAlreadyAssigned(int cycle, const MoveNode &node, const TTAMachine::Bus *preassignedBus) const =0
AssignmentPlan::srcFU_
const TTAMachine::FunctionUnit * srcFU_
Definition: AssignmentPlan.hh:95
PendingAssignment::forget
void forget()
Definition: PendingAssignment.cc:164
MoveNode::toString
std::string toString() const
Definition: MoveNode.cc:576
AssignmentPlan::dstFU_
const TTAMachine::FunctionUnit * dstFU_
Definition: AssignmentPlan.hh:96
OutOfRange
Definition: Exception.hh:320
ResourceBroker
Definition: ResourceBroker.hh:61
AssignmentPlan::currentBroker_
int currentBroker_
Current broker.
Definition: AssignmentPlan.hh:112
TTAProgram::Move::bus
const TTAMachine::Bus & bus() const
Definition: Move.cc:373
AssignmentPlan::lastTestedWorkingAssignment_
std::vector< std::pair< ResourceBroker *, SchedulingResource * > > lastTestedWorkingAssignment_
cache.
Definition: AssignmentPlan.hh:118
ResourceBroker::isApplicable
virtual bool isApplicable(const MoveNode &node, const TTAMachine::Bus *preassignedBus) const =0
PendingAssignment::broker
ResourceBroker & broker()
Definition: PendingAssignment.cc:61
MoveNode::unsetCycle
void unsetCycle()
Definition: MoveNode.cc:519
AssignmentPlan::immRegIndex_
int immRegIndex_
Definition: AssignmentPlan.hh:99
debugLogRM
#define debugLogRM(__X)
Definition: ResourceManager.hh:123
MoveNode::isPlaced
bool isPlaced() const
Definition: MoveNode.cc:352
AssignmentPlan::immu_
const TTAMachine::ImmediateUnit * immu_
Definition: AssignmentPlan.hh:98
MoveNode::cycle
int cycle() const
Definition: MoveNode.cc:421
AssignmentPlan::node_
MoveNode * node_
Move of current resource assignment request.
Definition: AssignmentPlan.hh:108
InvalidData
Definition: Exception.hh:149
AssignmentPlan::applicableAssignments_
std::vector< PendingAssignment * > applicableAssignments_
Sequence of applicable pending assignments.
Definition: AssignmentPlan.hh:104
AssocTools::deleteAllItems
static void deleteAllItems(ContainerType &aMap)
__func__
#define __func__
Definition: Application.hh:67
PendingAssignment::resource
SchedulingResource & resource(int index)
Definition: PendingAssignment.hh:66
AssignmentPlan::currentBroker
ResourceBroker & currentBroker()
Definition: AssignmentPlan.cc:179
AssignmentPlan::clearCache
void clearCache()
Definition: AssignmentPlan.cc:464
ModuleRunTimeError
Definition: Exception.hh:1043
AssignmentPlan::broker
ResourceBroker & broker(int index) const
Definition: AssignmentPlan.cc:436
AssignmentPlan::assignments_
std::vector< PendingAssignment * > assignments_
Sequence of pending assignments.
Definition: AssignmentPlan.hh:102
PendingAssignment::lastTriedAssignment
int lastTriedAssignment() const
Definition: PendingAssignment.hh:68
AssignmentPlan::immWriteCycle_
int immWriteCycle_
Definition: AssignmentPlan.hh:97
PendingAssignment::tryNext
void tryNext()
Definition: PendingAssignment.cc:119
MoveNode::move
TTAProgram::Move & move()
MoveNode::setCycle
void setCycle(const int newcycle)
Definition: MoveNode.cc:503
AssignmentPlan::lastTriedNode_
MoveNode * lastTriedNode_
Definition: AssignmentPlan.hh:119
PendingAssignment
Definition: PendingAssignment.hh:48
AssignmentPlan::lastTriedCycle_
int lastTriedCycle_
Definition: AssignmentPlan.hh:120
TCEString
Definition: TCEString.hh:53
AssignmentPlan::brokers_
std::vector< ResourceBroker * > brokers_
Sequence of resource brokers.
Definition: AssignmentPlan.hh:106
AssignmentPlan::bus_
const TTAMachine::Bus * bus_
Definition: AssignmentPlan.hh:94
AssignmentPlan::resourceFound_
bool resourceFound_
True if a valid resource of current broker has been assigned.
Definition: AssignmentPlan.hh:114
AssignmentPlan::cycle_
int cycle_
Cycle in which current node should be placed.
Definition: AssignmentPlan.hh:110
PendingAssignment::undoAssignment
void undoAssignment()
Definition: PendingAssignment.cc:146