#include <ExecutionPipelineBroker.hh>

Inheritance diagram for ExecutionPipelineBroker:

Collaboration diagram for ExecutionPipelineBroker:

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

virtual	~ExecutionPipelineBroker ()

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 *) const override

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

virtual void	setupResourceLinks (const ResourceMapper &mapper) override

virtual int	highestKnownCycle () const

virtual bool	isExecutionPipelineBroker () const override

virtual void	setInitiationInterval (unsigned int cycles) override

virtual int	longestLatency () const

virtual void	setMaxCycle (unsigned int maxCycle) override

void	setDDG (const DataDependenceGraph *ddg)

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 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

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

void	validateResources () const

virtual std::string	brokerName () const

void	resources (ResourceSet &contents)

virtual void	clear ()

Private Types
typedef std::map< SchedulingResource , const TTAMachine::FunctionUnit >	FUPipelineMap
	Map to link FU's and pipelines.

Private Member Functions
bool	isMoveTrigger (const MoveNode &node) const

bool	isLoopBypass (const MoveNode &node) const

int	latestFromSource (int, const MoveNode &, const TTAMachine::FunctionUnit *srcFU) const

int	latestFromDestination (int, const MoveNode &, const TTAMachine::FunctionUnit *dstFU) const

int	earliestFromSource (int, const MoveNode &, const TTAMachine::FunctionUnit *srcFU) const

int	earliestFromDestination (int, const MoveNode &, const TTAMachine::FunctionUnit *dstFU) const

Private Attributes
FUPipelineMap	fuPipelineMap_
	FU's and their corresponding pipeline resources.

int	longestLatency_
	Longest latency of all operations of all the FUs.

const DataDependenceGraph *	ddg_

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

Execution pipeline broker.

Definition at line 53 of file ExecutionPipelineBroker.hh.

Member Typedef Documentation

◆ FUPipelineMap

typedef std::map<SchedulingResource*, const TTAMachine::FunctionUnit*> ExecutionPipelineBroker::FUPipelineMap

private

Map to link FU's and pipelines.

Definition at line 97 of file ExecutionPipelineBroker.hh.

Constructor & Destructor Documentation

◆ ExecutionPipelineBroker()

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

Constructor.

Definition at line 62 of file ExecutionPipelineBroker.cc.

                                        : 
    ResourceBroker(name, initiationInterval), longestLatency_(0), ddg_(NULL) {
        
    // change ii for broker's resources also
    for (FUPipelineMap::iterator i = fuPipelineMap_.begin();
            i != fuPipelineMap_.end(); ++i) {
        i->first->setInitiationInterval(initiationInterval);
    }
}

References fuPipelineMap_, and ResourceBroker::setInitiationInterval().

Here is the call graph for this function:

◆ ~ExecutionPipelineBroker()

ExecutionPipelineBroker::~ExecutionPipelineBroker ( )

virtual

Destructor.

Definition at line 85 of file ExecutionPipelineBroker.cc.

85 {

86}

Member Function Documentation

◆ assign()

void ExecutionPipelineBroker::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.

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.

Note: The execution pipeline broker is used only to construct resources.

Implements ResourceBroker.

Definition at line 102 of file ExecutionPipelineBroker.cc.

{
    abortWithError("Not implemented.");
}

References abortWithError.

◆ buildResources()

void ExecutionPipelineBroker::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 255 of file ExecutionPipelineBroker.cc.

                                                                       {
 
    Machine::FunctionUnitNavigator navi = target.functionUnitNavigator();
    for (int i = 0; i < navi.count(); i++) {
        FunctionUnit* fu = navi.item(i);
        ExecutionPipelineResource* epResource =
            new ExecutionPipelineResource(
                *fu, initiationInterval_);
        
        ResourceBroker::addResource(*fu, epResource);
        fuPipelineMap_.insert(
            pair<SchedulingResource*, const FunctionUnit*>(epResource, fu));
        longestLatency_ = 
            (longestLatency_ < fu->maxLatency()) 
                ? fu->maxLatency() : longestLatency_;            
    }
 
    ControlUnit* gcu = target.controlUnit();
 
    ExecutionPipelineResource* epResource =
    new ExecutionPipelineResource(*gcu, initiationInterval_);
 
    ResourceBroker::addResource(*gcu, epResource);
    fuPipelineMap_.insert(pair<SchedulingResource*, const
            FunctionUnit*>(epResource, gcu));
}

References ResourceBroker::addResource(), TTAMachine::Machine::controlUnit(), TTAMachine::Machine::Navigator< ComponentType >::count(), TTAMachine::Machine::functionUnitNavigator(), fuPipelineMap_, ResourceBroker::initiationInterval_, TTAMachine::Machine::Navigator< ComponentType >::item(), longestLatency_, and TTAMachine::FunctionUnit::maxLatency().

Here is the call graph for this function:

◆ earliestCycle()

int ExecutionPipelineBroker::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.

Considers source and destination terminals independently and compares the results. Returns -1 if no assignment is possible.

Parameters

cycle	Cycle.
node	Node.
srcFU	if not null, srcFu that has to be used.
dstFU	if not null, dstFU that has to be used.
immWriteCycle	if not -1 and src is imm, write cycle of limm.

Implements ResourceBroker.

Definition at line 137 of file ExecutionPipelineBroker.cc.

          {
    
    int efs = earliestFromSource(cycle, node, srcFU);
    if (efs == -1 || efs == INT_MAX) {
        debugLogRM("returning -1");
        return -1;
    }
    int efd = earliestFromDestination(efs, node, dstFU);
    if (efd == -1 || efd == INT_MAX) {
        debugLogRM("returning -1");
        return -1;
    }
    
    // Loop as long as we find cycle which work for both source and 
    // destination.
    while (efd != efs) {
        efs = earliestFromSource(efd, node, srcFU);
        if (efs == -1 || efs == INT_MAX) {
            debugLogRM("returning -1");
            return -1;
        }
        if (efs == efd) {
            return efd;
        }
        efd = earliestFromDestination(efs, node, dstFU);
        if (efd == -1 || efd == INT_MAX) {
            debugLogRM("returning -1");
            return -1;
        }
    }
    return efd;
}

References debugLogRM, earliestFromDestination(), and earliestFromSource().

Referenced by SimpleBrokerDirector::earliestCycle().

Here is the call graph for this function:

◆ earliestFromDestination()

int ExecutionPipelineBroker::earliestFromDestination	(	int	cycle,
		const MoveNode &	node,
		const TTAMachine::FunctionUnit *	dstFU
	)		const

private

Return earliest cycle, starting from given parameter and going towards INT_MAX, in which the node can be scheduled. Taking into account destination terminal of Move (operand write).

This method may return too early for some cases but there is canassign test after this always at higher level in RM so this does not matter; having this method is just performance optimization to avoid calling slow canAssign() for too small values.

Parameters

cycle	Starting cycle for tests
node	MoveNode to find earliest cycle for

Returns: The earliest cycle in which the MoveNode can be scheduled, -1 if scheduling is not possible, 0 if destination is not FUPort

Definition at line 719 of file ExecutionPipelineBroker.cc.

                                                                     {
 
    if (!node.isDestinationOperation()) {
        return cycle;
    }
    const FunctionUnit* fu = NULL;
 
    int minCycle = cycle;
 
    bool triggers = isMoveTrigger(node);
 
    for (unsigned int j = 0; j < node.destinationOperationCount(); j++) {
        
        const HWOperation* hwop = NULL;
        // Test other inputs to the operation.
        ProgramOperation& destOp = node.destinationOperation(j);
        
        for (int i = 0; i < destOp.inputMoveCount(); i++) {
            const MoveNode* tempNode = &destOp.inputMove(i);
            if (tempNode->isScheduled() && tempNode != &node) {
                fu = &tempNode->move().destination().functionUnit();
                hwop = fu->operation(destOp.operation().name());
                if (dstFU != NULL && fu != dstFU) {
                    return -1;
                }
 
                if (triggers) {
                    // TODO: operand slack
                    minCycle = std::max(tempNode->cycle(), minCycle);
                }
                if (tempNode->move().isTriggering()) {
                    // TODO: operand slack
                    int triggerCycle = tempNode->cycle();
                    if (triggerCycle < cycle) {
                        // trying to schedule operand after trigger
                        debugLogRM("returning -1");
                        return -1;
                    }
                }
            }
        }
 
        // Then check the already scheduled results, do they limit the cycle
        // where this can be scheduled.
        int minResultCycle = INT_MAX;
        for (int i = 0; i < destOp.outputMoveCount(); i++) {
            const MoveNode* tempNode = &destOp.outputMove(i);
            if (tempNode->isScheduled()) {
                if (fu == NULL) {
                    fu = destOp.fuFromOutMove(*tempNode);
                    hwop = fu->operation(destOp.operation().name());
                }
 
                if (dstFU != NULL && fu != dstFU) {
                    return -1;
                }
 
                const int outputIndex =
                    destOp.outputIndexOfMove(*tempNode);
 
                // TODO: slack
                
                unsigned int latency = hwop->latency(outputIndex);
                if (initiationInterval_ != 0 && latency >= initiationInterval_) {
                    debugLogRM("returning -1");
                    return -1;
                }
                minResultCycle =
                    std::min(
                        minResultCycle,
                        tempNode->cycle() - hwop->latency(outputIndex));
            }
        }
        if (minResultCycle < minCycle) {
            // tested cycle is larger then last trigger cycle for results
            // already scheduled
            debugLogRM("returning -1");
            return -1;
        }  
    }
 
    return minCycle;
}

References MoveNode::cycle(), debugLogRM, TTAProgram::Move::destination(), MoveNode::destinationOperation(), MoveNode::destinationOperationCount(), ProgramOperation::fuFromOutMove(), TTAProgram::Terminal::functionUnit(), ResourceBroker::initiationInterval_, ProgramOperation::inputMove(), ProgramOperation::inputMoveCount(), MoveNode::isDestinationOperation(), isMoveTrigger(), MoveNode::isScheduled(), TTAProgram::Move::isTriggering(), TTAMachine::HWOperation::latency(), MoveNode::move(), Operation::name(), ProgramOperation::operation(), TTAMachine::FunctionUnit::operation(), ProgramOperation::outputIndexOfMove(), ProgramOperation::outputMove(), and ProgramOperation::outputMoveCount().

Referenced by earliestCycle().

Here is the call graph for this function:

◆ earliestFromSource()

int ExecutionPipelineBroker::earliestFromSource	(	int	cycle,
		const MoveNode &	node,
		const TTAMachine::FunctionUnit *	srcFU
	)		const

private

Returns earliest cycle, starting from given parameter and going towards INT_MAX, in which the node can be scheduled. Taking into account source Terminal of Move (result read) and other operands already scheduled.

Parameters

cycle	Starting cycle for tests
node	MoveNode to find earliest cycle for

Returns: The earliest cycle in which the MoveNode can be scheduled, 0 if source is not FUPort

Definition at line 600 of file ExecutionPipelineBroker.cc.

          {
    
    if (!node.isSourceOperation()) {
        return cycle;
    }
    ProgramOperation& sourceOp = node.sourceOperation();
    const MoveNode* triggerNode = NULL;
    int minCycle = -1;
 
    const FunctionUnit* fu = NULL;
    assert(node.move().source().isFUPort());
 
    const HWOperation* hwop = NULL;
    const int outputIndex =
        node.move().source().operationIndex();
    int latency = 1;
    
    for (int i = 0; i < sourceOp.inputMoveCount(); i++) {
        const MoveNode* tempNode = &sourceOp.inputMove(i);
        if (tempNode->isScheduled() && tempNode != &node) {
            fu = &tempNode->move().destination().functionUnit();
            if (srcFU != NULL&& fu != srcFU) {
                return -1;
            }
            minCycle = std::max(tempNode->cycle()+1, minCycle);
            if (tempNode->move().isTriggering()) {
                triggerNode = tempNode;
                hwop = fu->operation(sourceOp.operation().name());
                latency = hwop->latency(outputIndex);
                minCycle = std::max(triggerNode->cycle() + latency, cycle);
            }
        }
    }
    if (minCycle == -1) {
        // no operands scheduled for result of given PO
        // so earliest cycle is 0 + latency or tested cycle
        if (initiationInterval_ != 0 && latency >= (int)initiationInterval_) {
            debugLogRM("returning -1");
            return -1;
        }
        minCycle = std::max(cycle,1); 
    }
 
    if (triggerNode != NULL && triggerNode->isScheduled()) {
        int triggerCycle = triggerNode->cycle();
 
        const TTAMachine::Port& port = *hwop->port(outputIndex);
        SchedulingResource& res = *resourceOf(*fu);
        ExecutionPipelineResource* ep =
            static_cast<ExecutionPipelineResource*>(&res);
 
        if (!ep->resultNotOverWritten(
                minCycle, node.earliestResultReadCycle(), node,
                port, triggerNode, triggerCycle)) {
            return -1;
        }
    }
 
    return std::max(minCycle, cycle);
}

References assert, MoveNode::cycle(), debugLogRM, TTAProgram::Move::destination(), MoveNode::earliestResultReadCycle(), TTAProgram::Terminal::functionUnit(), ResourceBroker::initiationInterval_, ProgramOperation::inputMove(), ProgramOperation::inputMoveCount(), TTAProgram::Terminal::isFUPort(), MoveNode::isScheduled(), MoveNode::isSourceOperation(), TTAProgram::Move::isTriggering(), TTAMachine::HWOperation::latency(), MoveNode::move(), Operation::name(), ProgramOperation::operation(), TTAMachine::FunctionUnit::operation(), TTAProgram::Terminal::operationIndex(), TTAMachine::HWOperation::port(), ResourceBroker::resourceOf(), ExecutionPipelineResource::resultNotOverWritten(), TTAProgram::Move::source(), and MoveNode::sourceOperation().

Referenced by earliestCycle().

Here is the call graph for this function:

◆ highestKnownCycle()

int ExecutionPipelineBroker::highestKnownCycle ( ) const

virtual

Return the highest cycle any of the pipeline is known to be used

Returns: A highest cycle in which any of the pipelines is used.

Definition at line 366 of file ExecutionPipelineBroker.cc.

                                                 {
    int localMax = 0;
    for (ResourceMap::const_iterator resIter = resMap_.begin();
        resIter != resMap_.end(); resIter++) {
        ExecutionPipelineResource* ep =
            (dynamic_cast<ExecutionPipelineResource*>((*resIter).second));
        localMax = std::max(ep->highestKnownCycle(), localMax);
    }
    return localMax;
}

References ExecutionPipelineResource::highestKnownCycle(), and ResourceBroker::resMap_.

Here is the call graph for this function:

◆ isAlreadyAssigned()

bool ExecutionPipelineBroker::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 222 of file ExecutionPipelineBroker.cc.

                                                      {
    abortWithError("Not implemented.");
    return false;
}

References abortWithError.

◆ isApplicable()

bool ExecutionPipelineBroker::isApplicable	(	const MoveNode &	node,
		const TTAMachine::Bus *
	)		const

overridevirtual

Return true if the given node needs a resource of the type managed by this broker, false otherwise.

Parameters

node Node.

Returns: Always false. Broker is not used standalone, only for creating resources and setting up resource links.

Note: Broker is used only to construct resources, the assignment and unassignment is done via ExecutionPipelineResource attached to InputFuResource.

Implements ResourceBroker.

Definition at line 240 of file ExecutionPipelineBroker.cc.

                                                 {
    return false;
}

◆ isExecutionPipelineBroker()

bool ExecutionPipelineBroker::isExecutionPipelineBroker ( ) const

overridevirtual

Reimplemented from ResourceBroker.

Definition at line 378 of file ExecutionPipelineBroker.cc.

                                                         {
    return true;
}

◆ isLoopBypass()

bool ExecutionPipelineBroker::isLoopBypass ( const MoveNode & node ) const

private

Definition at line 399 of file ExecutionPipelineBroker.cc.

                                                                     {
 
    if (ddg_ == NULL || !ddg_->hasNode(node)) {
        return false;
    }
    auto inEdges = ddg_->operationInEdges(node);
    for (auto e : inEdges) {
        if (e->isBackEdge()) {
            return true;
        }
    }
    return false;
}

References ddg_, BoostGraph< GraphNode, GraphEdge >::hasNode(), and DataDependenceGraph::operationInEdges().

Referenced by latestFromDestination(), and latestFromSource().

Here is the call graph for this function:

◆ isMoveTrigger()

bool ExecutionPipelineBroker::isMoveTrigger ( const MoveNode & node ) const

private

Definition at line 664 of file ExecutionPipelineBroker.cc.

                                                                     {
    if (!node.isDestinationOperation()) {
        return false;
    }
 
    for (unsigned int j = 0; j < node.destinationOperationCount(); j++) {
//        const HWOperation* hwop = NULL;
 
        // Test other inputs to the operation.
        ProgramOperation& destOp = node.destinationOperation(j);
        
        for (int i = 0; i < destOp.inputMoveCount(); i++) {
            const MoveNode* tempNode = &destOp.inputMove(i);
            if (tempNode->isScheduled()) {
                if (tempNode->move().isTriggering()) {
                    if (tempNode != &node) {
                        return false;
                        break;
                    } else {
                        return true;
                    }
                }
                auto fu = &tempNode->move().destination().functionUnit();
                auto triggeringPort = fu->triggerPort();
                auto hwop = fu->operation(
                    node.destinationOperation().operation().name());
                auto port = hwop->port(
                    node.move().destination().operationIndex());
                if (port == triggeringPort) {
                    return true;
                } else {
                    return false;
                }
            }
        }
    }
    return false;
}

References TTAProgram::Move::destination(), MoveNode::destinationOperation(), MoveNode::destinationOperationCount(), TTAProgram::Terminal::functionUnit(), ProgramOperation::inputMove(), ProgramOperation::inputMoveCount(), MoveNode::isDestinationOperation(), MoveNode::isScheduled(), TTAProgram::Move::isTriggering(), MoveNode::move(), Operation::name(), ProgramOperation::operation(), TTAProgram::Terminal::operationIndex(), and TTAMachine::FunctionUnit::triggerPort().

Referenced by earliestFromDestination().

Here is the call graph for this function:

◆ latestCycle()

int ExecutionPipelineBroker::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.
srcFU	if not null, srcFu that has to be used.
dstFU	if not null, dstFU that has to be used.
immWriteCycle	if not -1 and src is imm, write cycle of limm.

Returns: The latest cycle, starting from given cycle backwards, where a resource of the type managed by this broker can be assigned to the given node. Considers source and destination terminals independently and compares the results. Returns -1 if no assignment is possible.

Implements ResourceBroker.

Definition at line 193 of file ExecutionPipelineBroker.cc.

                                                {
    int src = latestFromSource(cycle,node, srcFU);
    if (src == -1) {
        return -1;
    }
    int dst = latestFromDestination(src, node, dstFU);
    return dst;
}

References latestFromDestination(), and latestFromSource().

Referenced by SimpleBrokerDirector::latestCycle().

Here is the call graph for this function:

◆ latestFromDestination()

int ExecutionPipelineBroker::latestFromDestination	(	int	cycle,
		const MoveNode &	node,
		const TTAMachine::FunctionUnit *	dstUnit
	)		const

private

Returns latest cycle, starting from given parameter and going towards zero, in which the node can be scheduled. Taking into account destination terminal of Move (operand write).

Parameters

cycle	Starting cycle for tests
node	MoveNode to find latest cycle for

Returns: The latest cycle in which the MoveNode can be scheduled, -1 if scheduling is not possible, 'cycle' if destination is not FUPort

Definition at line 538 of file ExecutionPipelineBroker.cc.

                                                                       {
 
    // TODO: this not do full reuslt overwrite another tests.
    // It is however handled in canassign(). 
    // Doing it here would make scheduling faster.
    int latest = cycle;
    for (unsigned int j = 0; j < node.destinationOperationCount(); j++) {
        ProgramOperation& destOp = node.destinationOperation(j);
        for (int i = 0; i < destOp.inputMoveCount(); i++) {
            const MoveNode* tempNode = &destOp.inputMove(i);
            if (tempNode->isScheduled() && tempNode != &node) {
                if (tempNode->move().isTriggering()) {
                    latest = std::min(tempNode->cycle(), latest);
                }
            }
        }
 
        for (int i = 0; i < destOp.outputMoveCount(); i++) {
            const MoveNode* tempNode = &destOp.outputMove(i);
            if (tempNode->isScheduled() && tempNode != &node) {
                const TTAMachine::FunctionUnit* fu =
                    &node.move().destination().functionUnit();
                if (dstUnit != NULL && dstUnit != fu) {
                    return -1;
                }
                const TTAMachine::HWOperation& hwop =
                    *fu->operation(
                        destOp.operation().name());
                const int outputIndex =
                    (tempNode->isSourceOperation() &&
                     &tempNode->sourceOperation() == &destOp)
                    ?
                    tempNode->move().source().operationIndex() :
                    destOp.outputIndexFromGuardOfMove(*tempNode);
 
                int tempCycle = tempNode->cycle();
                if (isLoopBypass(*tempNode)) {
                    tempCycle += initiationInterval_;
                }
 
                latest = std::min(latest,
                                  tempCycle - hwop.latency(outputIndex));
            }
        }
    }
 
    return latest;
}

References MoveNode::cycle(), TTAProgram::Move::destination(), MoveNode::destinationOperation(), MoveNode::destinationOperationCount(), TTAProgram::Terminal::functionUnit(), ResourceBroker::initiationInterval_, ProgramOperation::inputMove(), ProgramOperation::inputMoveCount(), isLoopBypass(), MoveNode::isScheduled(), MoveNode::isSourceOperation(), TTAProgram::Move::isTriggering(), TTAMachine::HWOperation::latency(), MoveNode::move(), Operation::name(), ProgramOperation::operation(), TTAMachine::FunctionUnit::operation(), TTAProgram::Terminal::operationIndex(), ProgramOperation::outputIndexFromGuardOfMove(), ProgramOperation::outputMove(), ProgramOperation::outputMoveCount(), TTAProgram::Move::source(), and MoveNode::sourceOperation().

Referenced by latestCycle().

Here is the call graph for this function:

◆ latestFromSource()

int ExecutionPipelineBroker::latestFromSource	(	int	cycle,
		const MoveNode &	node,
		const TTAMachine::FunctionUnit *	srcFU
	)		const

private

Returns latest cycle, starting from given parameter and going towards zero, in which the node can be scheduled. Taking into account source terminal of Move (result read).

Parameters

cycle	Starting cycle for tests
node	MoveNode to find latest cycle for

Returns: The latest cycle in which the MoveNode can be scheduled, -1 if scheduling is not possible, 'cycle' if source is not FUPort

Definition at line 425 of file ExecutionPipelineBroker.cc.

         {
 
    if (!node.isSourceOperation()) {
        return cycle;
    }
    // kludge for looop bypass.
    ProgramOperation& sourceOp = node.sourceOperation();
    if (isLoopBypass(node)) {
        cycle+=initiationInterval_;
    }
    const MoveNode* triggerNode = NULL;
    const MoveNode* lastOperandNode = NULL;
    const MoveNode* lastResultNode = NULL;    
    int minCycle = -1;
    // Source is result read, we test all operands
    for (int i = 0; i < sourceOp.inputMoveCount(); i++) {
        const MoveNode* tempNode = &sourceOp.inputMove(i);
        if (tempNode->isScheduled() && tempNode != &node) {
            minCycle = std::max(tempNode->cycle(), minCycle);
            lastOperandNode = tempNode;
            if (tempNode->move().isTriggering()) {
                triggerNode = tempNode;
            }
        }
    }
    // Source is result read, we test all results    
    for (int i = 0; i < sourceOp.outputMoveCount(); i++) {
        const MoveNode* tempNode = &sourceOp.outputMove(i);
        if (tempNode->isScheduled() && tempNode != &node) {
            int tempCycle = tempNode->cycle();
            if (isLoopBypass(*tempNode)) {
                tempCycle += initiationInterval_;
            }
            minCycle = std::max(tempCycle, minCycle);
            lastResultNode = tempNode;
        }
    }
    
    if (minCycle == -1) {
        return cycle;
    }
    if (minCycle > cycle && lastResultNode == NULL) {
        // Some operand is already later then where we started to backtrack.
        debugLogRM("returning -1");
        return -1;
    }
    if (triggerNode != NULL) {
        
        if (minCycle >= node.earliestResultReadCycle() 
            && lastResultNode == NULL) {
            // If we do have minCycle from operands, this is valid test,
            // otherwise it is not.
            throw InvalidData(__FILE__, __LINE__, __func__, 
                "Some operand move is written after the result move "
                "is ready! " + node.toString());
        }
        if (node.earliestResultReadCycle() > cycle) {
            // Result is available later then where we started to backtrack
            debugLogRM("returning -1");
            return -1;
        } else {
            minCycle = node.earliestResultReadCycle();
        }
    }
    // minCycle has latest of operand writes or earliest result read cycle
    // find next read of same FU with different PO
    assert(lastOperandNode != NULL || lastResultNode != NULL);
    const TTAMachine::FunctionUnit* fu;
    if (lastOperandNode != NULL) {
        fu = &lastOperandNode->move().destination().functionUnit();
    } else {
        if (lastResultNode->isSourceOperation()) {
            fu = &lastResultNode->move().source().functionUnit();
        } else {
            assert(lastResultNode->isGuardOperation());
            fu = lastResultNode->guardOperation().fuFromOutMove(*lastResultNode);
        }
    }
 
    if (srcFU != NULL && fu != srcFU) {
        return -1;
    }
    HWOperation& hwop = *fu->operation(sourceOp.operation().name());
    const TTAMachine::Port& port =
        *hwop.port(node.move().source().operationIndex());
    SchedulingResource& res = *resourceOf(*fu);
    ExecutionPipelineResource* ep =
        static_cast<ExecutionPipelineResource*>(&res);
    int triggerCycle = triggerNode != NULL && triggerNode->isScheduled() ? 
        triggerNode->cycle() : 
        INT_MAX;
    // last available cycle is one lower then next write
 
    int nextResult = ep->nextResultCycle(
        port, minCycle, node, triggerNode, triggerCycle);
    if (cycle < nextResult || nextResult < minCycle) {
        return cycle;
    }
    return nextResult-1;
}

References __func__, assert, MoveNode::cycle(), debugLogRM, TTAProgram::Move::destination(), MoveNode::earliestResultReadCycle(), ProgramOperation::fuFromOutMove(), TTAProgram::Terminal::functionUnit(), MoveNode::guardOperation(), ResourceBroker::initiationInterval_, ProgramOperation::inputMove(), ProgramOperation::inputMoveCount(), MoveNode::isGuardOperation(), isLoopBypass(), MoveNode::isScheduled(), MoveNode::isSourceOperation(), TTAProgram::Move::isTriggering(), MoveNode::move(), Operation::name(), ExecutionPipelineResource::nextResultCycle(), ProgramOperation::operation(), TTAMachine::FunctionUnit::operation(), TTAProgram::Terminal::operationIndex(), ProgramOperation::outputMove(), ProgramOperation::outputMoveCount(), TTAMachine::HWOperation::port(), ResourceBroker::resourceOf(), TTAProgram::Move::source(), MoveNode::sourceOperation(), and MoveNode::toString().

Referenced by latestCycle().

Here is the call graph for this function:

◆ longestLatency()

virtual int ExecutionPipelineBroker::longestLatency ( ) const

inlinevirtual

Definition at line 88 of file ExecutionPipelineBroker.hh.

88{ return longestLatency_; }

References longestLatency_.

Referenced by SimpleBrokerDirector::latestCycle().

◆ setDDG()

void ExecutionPipelineBroker::setDDG ( const DataDependenceGraph * ddg )

Definition at line 806 of file ExecutionPipelineBroker.cc.

                                                              {
    for (ResourceMap::iterator i = resMap_.begin(); i != resMap_.end(); i++) {
        (static_cast<ExecutionPipelineResource*>(i->second))->setDDG(ddg);
    }
    ddg_ = ddg;
}

References ddg_, and ResourceBroker::resMap_.

Referenced by SimpleBrokerDirector::setDDG().

◆ setInitiationInterval()

void ExecutionPipelineBroker::setInitiationInterval ( unsigned int ii )

overridevirtual

Set initiation interval, if ii = 0 then initiation interval is not used.

Parameters

ii	initiation interval

Reimplemented from ResourceBroker.

Definition at line 388 of file ExecutionPipelineBroker.cc.

{
    initiationInterval_ = ii;
 
    // change ii for broker's resources also
    for (FUPipelineMap::iterator i = fuPipelineMap_.begin();
            i != fuPipelineMap_.end(); ++i) {
        i->first->setInitiationInterval(ii);
    }
}

References fuPipelineMap_, and ResourceBroker::initiationInterval_.

◆ setMaxCycle()

void ExecutionPipelineBroker::setMaxCycle ( unsigned int maxCycle )

overridevirtual

Reimplemented from ResourceBroker.

Definition at line 74 of file ExecutionPipelineBroker.cc.

                                                          {
    // change ii for broker's resources also
    for (FUPipelineMap::iterator i = fuPipelineMap_.begin();
            i != fuPipelineMap_.end(); ++i) {
        i->first->setMaxCycle(maxCycle);
    }
}

References fuPipelineMap_.

Referenced by SimpleBrokerDirector::setMaxCycle().

◆ setupResourceLinks()

void ExecutionPipelineBroker::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 291 of file ExecutionPipelineBroker.cc.

                                                                        {
 
    setResourceMapper(mapper);
 
    for (ResourceMap::iterator resIter = resMap_.begin();
         resIter != resMap_.end(); resIter++) {
 
        const FunctionUnit* fuOriginal =
            dynamic_cast<const FunctionUnit*>((*resIter).first);
        if (fuOriginal == NULL){
            throw InvalidData(
                __FILE__, __LINE__, __func__, 
                "ExecutionPipelineBroker has something "
                "else then FU registered!");
        }
 
        // resMap_ is local for broker, so it can only contain fu->epResource
        SchedulingResource* epResource = (*resIter).second;
 
        const FunctionUnit* fu = NULL;
 
        try {
            fu = MapTools::valueForKey<const FunctionUnit*>(
                    fuPipelineMap_, epResource);
        } catch (const Exception& e) {
            std::string msg = "Pipeline resource \'";
            msg += epResource->name();
            msg += "\' not found";
            abortWithError(msg);
        }
 
        for (int i = 0; i < fu->portCount(); i++) {
            BaseFUPort* port = fu->port(i);
            if (port->isTriggering()) {
                if (port->outputSocket() != NULL) {
                    try {
                        SchedulingResource& relatedRes =
                            mapper.resourceOf(*port->outputSocket());
                        epResource->addToRelatedGroup(0, relatedRes);
                    } catch (const KeyNotFound& e) {
                        std::string msg = "ExecutionPipelineBroker: finding ";
                        msg += " resource for Socket ";
                        msg += " failed with error: ";
                        msg += e.errorMessageStack();
                        msg += " for resource " + epResource->name();
                        throw KeyNotFound(
                            __FILE__, __LINE__, __func__, msg);
                    }                                
                    
                } else {
                    try {
                        SchedulingResource& relatedRes =
                            mapper.resourceOf(*port->inputSocket());
                        epResource->addToRelatedGroup(0, relatedRes);
                    } catch (const KeyNotFound& e) {
                        std::string msg = "ExecutionPipelineBroker: finding ";
                        msg += " resource for Socket ";
                        msg += " failed with error: ";
                        msg += e.errorMessageStack();
                        msg += " for resource " + epResource->name();
                        throw KeyNotFound(
                            __FILE__, __LINE__, __func__, msg);
                    }                                                    
                }
            }
        }
    }
}

References __func__, abortWithError, SchedulingResource::addToRelatedGroup(), Exception::errorMessageStack(), fuPipelineMap_, TTAMachine::Port::inputSocket(), TTAMachine::BaseFUPort::isTriggering(), MapTools::keyForValue(), SchedulingResource::name(), TTAMachine::Port::outputSocket(), TTAMachine::FunctionUnit::port(), TTAMachine::Unit::portCount(), ResourceBroker::resMap_, ResourceMapper::resourceOf(), and ResourceBroker::setResourceMapper().

Here is the call graph for this function:

◆ unassign()

void ExecutionPipelineBroker::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 118 of file ExecutionPipelineBroker.cc.

                                           {
    abortWithError("Not implemented.");
}

References abortWithError.

Member Data Documentation

◆ ddg_

const DataDependenceGraph* ExecutionPipelineBroker::ddg_

private

Definition at line 111 of file ExecutionPipelineBroker.hh.

Referenced by isLoopBypass(), and setDDG().

◆ fuPipelineMap_

FUPipelineMap ExecutionPipelineBroker::fuPipelineMap_

private

FU's and their corresponding pipeline resources.

Definition at line 108 of file ExecutionPipelineBroker.hh.

Referenced by buildResources(), ExecutionPipelineBroker(), setInitiationInterval(), setMaxCycle(), and setupResourceLinks().

◆ longestLatency_

int ExecutionPipelineBroker::longestLatency_

private

Longest latency of all operations of all the FUs.

Definition at line 110 of file ExecutionPipelineBroker.hh.

Referenced by buildResources(), and longestLatency().

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

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ FUPipelineMap

Constructor & Destructor Documentation

◆ ExecutionPipelineBroker()

◆ ~ExecutionPipelineBroker()

Member Function Documentation

◆ assign()

◆ buildResources()

◆ earliestCycle()

◆ earliestFromDestination()

◆ earliestFromSource()

◆ highestKnownCycle()

◆ isAlreadyAssigned()

◆ isApplicable()

◆ isExecutionPipelineBroker()

◆ isLoopBypass()

◆ isMoveTrigger()

◆ latestCycle()

◆ latestFromDestination()

◆ latestFromSource()

◆ longestLatency()

◆ setDDG()

◆ setInitiationInterval()

◆ setMaxCycle()

◆ setupResourceLinks()

◆ unassign()

Member Data Documentation

◆ ddg_

◆ fuPipelineMap_

◆ longestLatency_