AssignmentPlan Class Reference

#include <AssignmentPlan.hh>

Collaboration diagram for AssignmentPlan:

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)
ResourceBroker &	firstBroker ()
ResourceBroker &	nextBroker (ResourceBroker &pos)
ResourceBroker &	lastBroker ()
ResourceBroker &	currentBroker ()
void	advance ()
void	backtrack ()
void	tryNextAssignment ()
bool	isTestedAssignmentPossible ()
void	resetAssignments ()
void	resetAssignments (MoveNode &node)
int	brokerCount () const
ResourceBroker &	broker (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::Bus *	bus_
const TTAMachine::FunctionUnit *	srcFU_
const TTAMachine::FunctionUnit *	dstFU_
int	immWriteCycle_
const TTAMachine::ImmediateUnit *	immu_
int	immRegIndex_
std::vector< PendingAssignment * >	assignments_
	Sequence of pending assignments.
std::vector< PendingAssignment * >	applicableAssignments_
	Sequence of applicable pending assignments.
std::vector< ResourceBroker * >	brokers_
	Sequence of resource brokers.
MoveNode *	node_
	Move of current resource assignment request.
int	cycle_
	Cycle in which current node should be placed.
int	currentBroker_
	Current broker.
bool	resourceFound_
	True if a valid resource of current broker has been assigned.
std::vector< std::pair< ResourceBroker *, SchedulingResource * > >	lastTestedWorkingAssignment_
	cache.
MoveNode *	lastTriedNode_
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.

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

~AssignmentPlan()

AssignmentPlan::~AssignmentPlan ( )

virtual

Destructor.

Definition at line 58 of file AssignmentPlan.cc.

                               {
    AssocTools::deleteAllItems(assignments_);
}

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.

                        {
    if (resourceFound_) {
        currentBroker_++;
    } else {
        string msg = "Tried to advance before a valid assignment was made!";
        throw ModuleRunTimeError(__FILE__, __LINE__, __func__, msg);
    }
    if (currentBroker_ >= static_cast<int>(applicableAssignments_.size())) {
        string msg = "Advanced beyond last resource broker!";
        throw ModuleRunTimeError(__FILE__, __LINE__, __func__, msg);
    }
}

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.

                          {
    // forget assignment history and assignments for current broker
    PendingAssignment* assignment = applicableAssignments_[currentBroker_];
    assignment->forget();
    if (assignment->broker().isAlreadyAssigned(cycle_, *node_, bus_)) {
        assignment->undoAssignment();
    }
    currentBroker_--;
    if (currentBroker_ < 0) {
        string msg = "Backtracked beyond first resource broker!";
        throw ModuleRunTimeError(__FILE__, __LINE__, __func__, msg);
    } else {
        // undo possible assignments for broker we backtracked to
        assignment = applicableAssignments_[currentBroker_];
        if (assignment->broker().isAlreadyAssigned(cycle_, *node_, bus_)) {
            assignment->undoAssignment();
        }
    }
}

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

index

Index of broker.

Returns

The broker in the given index.

Exceptions

OutOfRange

if index is out of bounds.

Definition at line 436 of file AssignmentPlan.cc.

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

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.

                                  {
    return brokers_.size();
}

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.

                      {
    node_= NULL;
    cycle_ = 0;
    currentBroker_ = 0;
    resourceFound_ = false;
    for (size_t i = 0; i < assignments_.size(); i++) {
        assignments_[i]->clear();
    }
    bus_ = NULL;
    srcFU_ = NULL;
    dstFU_ = NULL;
    immWriteCycle_ = -1;
    immu_ = NULL;
    immRegIndex_ = -1;
    clearCache();
    applicableAssignments_.clear();
}

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.

                                {
    lastTestedWorkingAssignment_.clear();
    lastTriedCycle_ = -1;
    lastTriedNode_ = NULL;
}

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.

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

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.

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

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

broker

Resource broker to be inserted.

Definition at line 68 of file AssignmentPlan.cc.

                                                   {
    assignments_.push_back(new PendingAssignment(broker));
    brokers_.push_back(&broker);
}

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.

                                           {
    bool possible = 
        applicableAssignments_[currentBroker_]->isAssignmentPossible();
    if (possible) {
        // is this the last broker?
        if (currentBroker_ == (int)(applicableAssignments_.size())-1) {
            // add this to the cache. 
            // first clear the cache.
            lastTestedWorkingAssignment_.clear();
            // then set the cache for this assignment.
            lastTriedNode_ = node_;
            lastTriedCycle_ = cycle_;
            for (unsigned int i = 0; i < applicableAssignments_.size()-1; 
                 i++) {
                PendingAssignment& pa = *applicableAssignments_[i];
                lastTestedWorkingAssignment_.push_back(
                    std::pair<ResourceBroker*, SchedulingResource*>(
                        &pa.broker(),
                        &pa.resource(pa.lastTriedAssignment())));
            }
            // Last one need to be handled separately because
            // tryNext has not increased lastTriedAssignment.
            if (!applicableAssignments_.empty()) {
                PendingAssignment& pa = *applicableAssignments_[
                    applicableAssignments_.size()-1];
                lastTestedWorkingAssignment_.push_back(
                    std::pair<ResourceBroker*, SchedulingResource*>(
                        &pa.broker(),
                        &pa.resource(pa.lastTriedAssignment()+1)));
            }
        }
    } else {
        debugLogRM("No applicable assignments at all:");
        debugLogRM(currentBroker().brokerName());
    }
    return possible;
}

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.

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

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.

                                              {
 
    if (applicableAssignments_.empty()) {
        string msg = "No applicable brokers found for assignment!";
        throw ModuleRunTimeError(__FILE__, __LINE__, __func__, msg);
    }
 
    unsigned int i = 0;
    while (i < applicableAssignments_.size() - 1) {
        if (&applicableAssignments_[i]->broker() == &pos) {
            return applicableAssignments_[++i]->broker();
        }
        i++;
    }
 
    string msg = "Given broker not found!";
    throw ModuleRunTimeError(__FILE__, __LINE__, __func__, msg);
}

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.

                                 {
    for (unsigned int i = 0; i < applicableAssignments_.size(); i++) {
        applicableAssignments_[i]->forget();
    }
    currentBroker_ = 0;
    node_->unsetCycle();
    bus_ = NULL;
}

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

node	Node to unassign.

Exceptions

InvalidData

If node is not placed on a cycle.

Definition at line 403 of file AssignmentPlan.cc.

                                               {
    if (!node.isPlaced()) {
        string msg = "Node is not placed in a cycle.";
        throw InvalidData(__FILE__, __LINE__, __func__, msg);
    }
    bus_ = &node.move().bus();
    for (unsigned int i = 0; i < brokers_.size(); i++) {
        if (brokers_[i]->isApplicable(node, bus_)) {
            brokers_[i]->unassign(node);
        }
    }
    node.unsetCycle();
    bus_ = NULL;
}

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

node	The node of current assignment request.
cycle	The cycle in which the node should be placed.

Definition at line 81 of file AssignmentPlan.cc.

                                            {
 
    if (node.isPlaced() && node.cycle() != cycle) {
        TCEString msg = "Node: " + node.toString();
        msg << "already placed on different cycle, cur cycle: " << cycle;
        throw ModuleRunTimeError(__FILE__, __LINE__, __func__, msg);
    }
 
    bus_ = bus;
    srcFU_ = srcFU;
    dstFU_ = dstFU;
    immWriteCycle_ = immWriteCycle;
    immu_ = immu;
    immRegIndex_ = immRegIndex;
 
    currentBroker_ = 0;
    node.setCycle(cycle);
 
    cycle_ = cycle;
    node_ = &node;
 
    // optimise broker sequence by disabling not applicable brokers
    applicableAssignments_.clear();
    for (unsigned int i = 0; i < assignments_.size(); i++) {
        if (assignments_[i]->broker().isApplicable(node, bus)) {
            assignments_[i]->setRequest(
        cycle, node, bus_, srcFU_, dstFU_, immWriteCycle_, immu_,
        immRegIndex_);
            applicableAssignments_.push_back(assignments_[i]);
        }
    }
    if (applicableAssignments_.empty()) {
        string msg = "No applicable brokers found for assignment!";
        throw ModuleRunTimeError(__FILE__, __LINE__, __func__, msg);
    }
}

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.

                                                     {
    // is the cache valid for this node?
    if (lastTriedNode_ != &node || 
        lastTriedCycle_ != cycle ||
        immRegIndex_ != immRegIndex ||
        immu != immu_ ||
        immWriteCycle_ != immWriteCycle ||
        srcFU_ != srcFU ||
        dstFU_ != dstFU ||
        lastTestedWorkingAssignment_.empty()) {
        clearCache();
        return false;
    }
 
    // test that same brokers are applicable for both cached and current.
    // may change in case of bypassing.
    for (size_t j = 0, i = 0; j < brokers_.size(); j++) {
        ResourceBroker* broker = brokers_[j];
        if (broker->isApplicable(node, bus)) {
            if (i >= lastTestedWorkingAssignment_.size() || 
                lastTestedWorkingAssignment_[i].first != broker) {
                clearCache();
                return false;
            }
            i++;
        } else {
            // if not applicable, must not found in the cached brokers.
            if (i < lastTestedWorkingAssignment_.size() &&
                lastTestedWorkingAssignment_[i].first == broker) {
                clearCache();
                return false;
            }
        }
    }
    node.setCycle(cycle);
 
    for (int i = 0; i < (int)lastTestedWorkingAssignment_.size(); i++) {
        std::pair<ResourceBroker*, SchedulingResource*>& ca =
            lastTestedWorkingAssignment_[i];
        if (!ca.first->isAvailable(
                *ca.second, node, cycle, bus, srcFU, dstFU, immWriteCycle,
        immu, immRegIndex)) {
            // failed. backtrack all previous brokers.
            // unassign, clear cache and return false.
            for (i--; i >= 0; i--) {
                std::pair<ResourceBroker*, SchedulingResource*>& ca =
                    lastTestedWorkingAssignment_[i];
                ca.first->unassign(node);
            }
            node.unsetCycle();
            clearCache();
            return false;
        } else {
            // can assign. do the assign.
            ca.first->assign(cycle, node, *ca.second, immWriteCycle, immRegIndex);
        }
    }
    // everything succeeded. clear cache(state of rm changed) and return true.
    clearCache();
    return true;
}

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.

                                  {
    PendingAssignment* assignment = applicableAssignments_[currentBroker_];
    if (assignment->broker().isAlreadyAssigned(cycle_, *node_, bus_)) {
        assignment->undoAssignment();
    }
    assignment->tryNext();
    resourceFound_ = true;
}

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

Sequence of applicable pending assignments.

Definition at line 104 of file AssignmentPlan.hh.

Referenced by advance(), backtrack(), clear(), currentBroker(), firstBroker(), isTestedAssignmentPossible(), lastBroker(), nextBroker(), resetAssignments(), setRequest(), and tryNextAssignment().

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(), resetAssignments(), setRequest(), and tryNextAssignment().

currentBroker_

int AssignmentPlan::currentBroker_

private

Current broker.

Definition at line 112 of file AssignmentPlan.hh.

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

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:

• AssignmentPlan.hh
• AssignmentPlan.cc