#include <ITemplateBroker.hh>

Inheritance diagram for ITemplateBroker:

Collaboration diagram for ITemplateBroker:

Public Member Functions
	ITemplateBroker (std::string, BusBroker &busBroker, unsigned int initiationInterval=0)

	ITemplateBroker (std::string, BusBroker &busBroker, SimpleResourceManager *, unsigned int initiationInterval=0)

virtual	~ITemplateBroker ()

virtual bool	isAnyResourceAvailable (int, const MoveNode &, const TTAMachine::Bus bus, const TTAMachine::FunctionUnit srcFU, const TTAMachine::FunctionUnit dstFU, int immWriteCycle, const TTAMachine::ImmediateUnit immu, int immRegIndex) const override

virtual SchedulingResourceSet	allAvailableResources (int, const MoveNode &, const TTAMachine::Bus bus, const TTAMachine::FunctionUnit srcUnit, const TTAMachine::FunctionUnit dstUnit, int immWriteCycle, const TTAMachine::ImmediateUnit immu, int immRegIndex) const override

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 srcUnit, const TTAMachine::FunctionUnit dstUnit, 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 srcUnit, const TTAMachine::FunctionUnit dstUnit, 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 bool	isITemplateBroker () const override

virtual TTAProgram::Instruction *	instruction (int cycle)

virtual void	loseInstructionOwnership (int cycle)

virtual bool	isTemplateAvailable (int, std::shared_ptr< TTAProgram::Immediate >) const

void	clearOldResources ()

void	clear () override

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

virtual	~ResourceBroker ()

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 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	isIUBroker () const

virtual bool	isExecutionPipelineBroker () const

void	validateResources () const

virtual std::string	brokerName () const

void	resources (ResourceSet &contents)

virtual void	setInitiationInterval (unsigned int cycles)

virtual void	setMaxCycle (unsigned int)

Private Types
typedef std::vector< std::shared_ptr< const TTAProgram::Move > >	Moves

typedef std::vector< std::shared_ptr< const TTAProgram::Immediate > >	Immediates

Private Member Functions
SchedulingResourceSet	findITemplates (int, Moves &, Immediates &) const

void	assignImmediate (int, std::shared_ptr< TTAProgram::Immediate >)

void	unassignImmediate (int, const TTAMachine::ImmediateUnit &)

bool	isImmediateInTemplate (int, std::shared_ptr< TTAProgram::Immediate >) const

void	reselectTemplate (TTAProgram::Instruction &ins, int cycle)

Private Attributes
std::vector< TTAMachine::Bus * >	slots_
	Move/immediate slots.

std::map< int, TTAProgram::Instruction * >	instructions_
	cycle/instruction

std::map< const MoveNode , TTAProgram::Instruction , MoveNode::Comparator >	oldParentInstruction_
	MoveNode/ original parent instruction.

std::map< const MoveNode *, int, GraphNode::Comparator >	immediateCycles_
	Record cycle for MoveNodes that needed immediate writes, IU broker restores immediates before the template broker is called so we need to explicitely find the Immediate to remove it from template.

std::map< const MoveNode *, std::shared_ptr< TTAProgram::Immediate >, GraphNode::Comparator >	immediateValues_

std::map< int, bool >	instructionsNotOwned_

SimpleResourceManager *	rm_

BusBroker &	busBroker_

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

ITemplate broker.

Definition at line 65 of file ITemplateBroker.hh.

Member Typedef Documentation

◆ Immediates

typedef std::vector<std::shared_ptr<const TTAProgram::Immediate> > ITemplateBroker::Immediates

private

Definition at line 124 of file ITemplateBroker.hh.

◆ Moves

typedef std::vector<std::shared_ptr<const TTAProgram::Move> > ITemplateBroker::Moves

private

Definition at line 123 of file ITemplateBroker.hh.

Constructor & Destructor Documentation

◆ ITemplateBroker() [1/2]

ITemplateBroker::ITemplateBroker	(	std::string	name,
		BusBroker &	busBroker,
		unsigned int	initiationInterval = `0`
	)

Constructor.

Definition at line 68 of file ITemplateBroker.cc.

                                                                           :
    ResourceBroker(name, initiationInterval),
    rm_(NULL), busBroker_(busBroker) {
}

◆ ITemplateBroker() [2/2]

ITemplateBroker::ITemplateBroker	(	std::string	name,
		BusBroker &	busBroker,
		SimpleResourceManager *	rm,
		unsigned int	initiationInterval = `0`
	)

Constructor.

Definition at line 77 of file ITemplateBroker.cc.

                                     :
    ResourceBroker(name, initiationInterval),
    rm_(rm), busBroker_(busBroker) {
}

◆ ~ITemplateBroker()

ITemplateBroker::~ITemplateBroker ( )

virtual

Destructor.

Definition at line 89 of file ITemplateBroker.cc.

                                 {
    for (std::map<int, TTAProgram::Instruction*>::iterator i =
             instructions_.begin(); i != instructions_.end(); i++) {
        std::map<int, bool>::iterator j = instructionsNotOwned_.find(i->first);
        // not found = >owns, deletes. 
        if (j == instructionsNotOwned_.end() || j->second == false) {
            delete i->second;
        }
    }
 
}

References instructions_, and instructionsNotOwned_.

Member Function Documentation

◆ allAvailableResources()

SchedulingResourceSet ITemplateBroker::allAvailableResources	(	int	cycle,
		const MoveNode &	node,
		const TTAMachine::Bus *	bus,
		const TTAMachine::FunctionUnit *	srcUnit,
		const TTAMachine::FunctionUnit *	dstUnit,
		int	immWriteCycle,
		const TTAMachine::ImmediateUnit *	immu,
		int	immRegIndex
	)		const

overridevirtual

Return all resources managed by this broker that can be assigned to the given node in the given cycle.

Parameters

cycle	Cycle.
node	Node.

Returns: All resources managed by this broker that can be assigned to the given node in the given cycle.

Note: This method is called twice, first it check available resources for immediate write, second call checks resources for MoveNode

Reimplemented from ResourceBroker.

Definition at line 144 of file ITemplateBroker.cc.

               {
    cycle = instructionIndex(cycle);
    Moves moves;
    Immediates immediates;
    MoveNode& testedNode = const_cast<MoveNode&>(node);
    if (node.isMove()) {
        moves.push_back(testedNode.movePtr());
    } else if (node.isImmediate()) {
        immediates.push_back(testedNode.immediatePtr());
    }
    return findITemplates(cycle, moves, immediates);
}

References findITemplates(), MoveNode::immediatePtr(), ResourceBroker::instructionIndex(), MoveNode::isImmediate(), MoveNode::isMove(), and MoveNode::movePtr().

Referenced by isAnyResourceAvailable().

Here is the call graph for this function:

◆ assign()

void ITemplateBroker::assign	(	int	cycle,
		MoveNode &	node,
		SchedulingResource &	res,
		int	immWriteCycle,
		int	immRegIndex
	)

overridevirtual

Assigns instruction template resource to the parent instruction of the given node.

Parameters

cycle	Cycle of node.
node	Node.
res	Instruction template resource to assign.

Exceptions

WrongSubclass	If this broker does not recognise the given type of resource.
InvalidData	If he given resource cannot be assigned to given node or no corresponding machine part is found.

Note: Ownership of a Move in MoveNode will be passed to Instruction inside the broker.

Implements ResourceBroker.

Definition at line 180 of file ITemplateBroker.cc.

                                                                 {
 
    cycle = instructionIndex(cycle);
 
    ITemplateResource& templateRes =
        static_cast<ITemplateResource&>(res);
    const InstructionTemplate& iTemplate =
        static_cast<const InstructionTemplate&>(machinePartOf(res));
    TTAProgram::Instruction* ins = NULL;
    if (MapTools::containsKey(instructions_, cycle)) {
        ins = MapTools::valueForKey<TTAProgram::Instruction*>(
            instructions_, cycle);
 
        // In case template was already assigned and it changes
        if (ins->instructionTemplate().name() != iTemplate.name()) {
            SchedulingResource& oldRes =
                *resourceOf(ins->instructionTemplate());
            ITemplateResource& oldTemplateRes =
                dynamic_cast<ITemplateResource&>(oldRes);
            oldTemplateRes.unassign(cycle);
 
            // In case the amount of transportable immediate bits decreases
            // due to ITemplate change, update each immediate bit width to
            // the new width. If this is not done, negative immediates ends up
            // to take more bits than they really need in TPEF and later
            // loading the TPEF fails in TPEFProgramFactory.
            for (int i = 0; i < ins->immediateCount(); i++) {
                // Can not change bit width of these.
                if (ins->immediate(i).value().isInstructionAddress() ||
                    ins->immediate(i).value().isBasicBlockReference() ||
                    ins->immediate(i).value().isCodeSymbolReference()) {
                    continue;
                }
                int currentWidth = ins->immediate(i).value().value().width();
                const ImmediateUnit& destIU =
                    ins->immediate(i).destination().immediateUnit();
                int newSupportedWidth = iTemplate.supportedWidth(destIU);
                if (currentWidth > newSupportedWidth) {
                    SimValue sim(
                        (destIU.signExtends() ?
                            ins->immediate(i).value().value().intValue() :
                            ins->immediate(i).value().value().unsignedValue()),
                        newSupportedWidth);
                    TerminalImmediate* ti = new TerminalImmediate(sim);
                    ins->immediate(i).setValue(ti);
                }
            }
 
            ins->setInstructionTemplate(iTemplate);
            templateRes.assign(cycle);
        }
    } else {
        ins = new TTAProgram::Instruction(iTemplate);
        instructions_[cycle] = ins;
        templateRes.assign(cycle);
    }
 
    Instruction* oldIn = NULL;
    if (node.isImmediate()) {
        oldIn = node.immediate().parent();
        if (oldIn != NULL) {
            oldIn->removeImmediate(node.immediate());
        }
        ins->addImmediate(node.immediatePtr());
    } else {
        if (node.move().isInInstruction()) {
            oldIn = &node.move().parent();
            oldIn->removeMove(node.move());
        }
        ins->addMove(node.movePtr());
    }
    oldParentInstruction_.insert(
        std::pair<const MoveNode*, TTAProgram::Instruction*>
        (&node, oldIn));
 
    // TODO: refactor this away.
    if (node.isSourceImmediateRegister()) {
        // Gets data from Immediate Unit broker, indirectly
 
        auto immValue = rm_->immediateValue(node);
        if (immValue) {
            TerminalImmediate* tempImm =
                dynamic_cast<TerminalImmediate*>(
                    immValue->copy());
            int defCycle = instructionIndex(rm_->immediateWriteCycle(node));
            if (defCycle >= 0) {
                TerminalRegister* tmpReg =
                    dynamic_cast<TerminalRegister*>(
                        node.move().source().copy());
                auto imm = std::make_shared<Immediate>(tempImm, tmpReg);
                if (!isImmediateInTemplate(defCycle,imm)) {
                    assignImmediate(defCycle, imm);
                    immediateCycles_.insert(
                        std::pair<const MoveNode*, int>(&node,defCycle));
                    immediateValues_.insert(
                        std::pair<const MoveNode*,
                        std::shared_ptr<TTAProgram::Immediate> >(
                            &node,imm));
                } else {
                    abortWithError("Failed to assign immediate write");
                }
            }
        }
    }
}

Here is the call graph for this function:

◆ assignImmediate()

void ITemplateBroker::assignImmediate	(	int	cycle,
		std::shared_ptr< TTAProgram::Immediate >	immediate
	)

private

Assigns instruction template resource to the given instruction located in given cycle.

Parameters

cycle	Cycle where to store immediate write.
immediate	Immediate to be written in cycle

Exceptions

WrongSubclass	If this broker does not recognise the given type of resource.
InvalidData	If he given resource cannot be assigned to given node or no corresponding machine part is found.

Definition at line 300 of file ITemplateBroker.cc.

                                                   {
    cycle = instructionIndex(cycle);
 
    try {
        // Find a template for definition cycle
        Moves moves;
        Immediates immediates;
        immediates.push_back(immediate);
 
        const SchedulingResourceSet& resources =
            findITemplates(cycle, moves, immediates);
        assert(resources.count());
        ITemplateResource& templateRes =
            static_cast<ITemplateResource&>(resources.resource(0));
         const InstructionTemplate& iTemplate =
            static_cast<const InstructionTemplate&>(
                machinePartOf(templateRes));
 
        // Find instruction, if there is none, create new.
        TTAProgram::Instruction* ins = NULL;
        if (MapTools::containsKey(instructions_, cycle)) {
            ins = MapTools::valueForKey<TTAProgram::Instruction*>(
                    instructions_, cycle);
            // Remove old template assignment
            SchedulingResource& oldRes =
                *resourceOf(ins->instructionTemplate());
            ITemplateResource& oldTemplateRes =
                static_cast<ITemplateResource&>(oldRes);
            oldTemplateRes.unassign(cycle);
        } else {
            ins = new TTAProgram::Instruction(iTemplate);
            instructions_[cycle] = ins;
        }
 
        // Define new immediate, depending on supported bit width of
        // template for given immediate unit
        const ImmediateUnit&  iu = immediate->destination().immediateUnit();
        int neededBitWidth = iTemplate.supportedWidth(iu);
        if (neededBitWidth <= INT_WORD_SIZE &&
            (!immediate->value().isInstructionAddress() &&
             !immediate->value().isBasicBlockReference() &&
             !immediate->value().isCodeSymbolReference())) {
            // If it is not floating point or instruction address
            // we recreate SimValue with proper bit width based on destination
            if (iu.extensionMode() == Machine::ZERO) {
                SimValue sim(
                    immediate->value().value().unsignedValue(), neededBitWidth);
                TerminalImmediate* ti = new TerminalImmediate(sim);
                immediate->setValue(ti);
            }
            if (iu.extensionMode() == Machine::SIGN) {
                SimValue sim(
                    immediate->value().value().intValue(), neededBitWidth);
                TerminalImmediate* ti = new TerminalImmediate(sim);
                immediate->setValue(ti);
            }
        }
 
        templateRes.assign(cycle);
        ins->setInstructionTemplate(iTemplate);        
        ins->addImmediate(immediate);
 
    } catch (const std::bad_cast& e) {
        string msg = "Resource is not of an instruction template resource.";
        throw WrongSubclass(__FILE__, __LINE__, __func__, msg);
    } catch (const KeyNotFound& e) {
        string msg = "Broker does not contain given resource.";
        throw InvalidData(__FILE__, __LINE__, __func__, msg);
    }
}

References __func__, TTAProgram::Instruction::addImmediate(), assert, ITemplateResource::assign(), MapTools::containsKey(), TTAMachine::ImmediateUnit::extensionMode(), findITemplates(), ResourceBroker::instructionIndex(), instructions_, TTAProgram::Instruction::instructionTemplate(), INT_WORD_SIZE, MapTools::keyForValue(), ResourceBroker::machinePartOf(), ResourceBroker::resourceOf(), ResourceBroker::resources(), TTAProgram::Instruction::setInstructionTemplate(), TTAMachine::Machine::SIGN, TTAMachine::InstructionTemplate::supportedWidth(), ITemplateResource::unassign(), and TTAMachine::Machine::ZERO.

Referenced by assign().

Here is the call graph for this function:

◆ buildResources()

void ITemplateBroker::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 596 of file ITemplateBroker.cc.

                                                               {
 
    Machine::InstructionTemplateNavigator templateNavi =
        target.instructionTemplateNavigator();
 
    for (int i = 0; i < templateNavi.count(); i++) {
        InstructionTemplate* itemplate = templateNavi.item(i);
        ITemplateResource* itemplateResource =
            new ITemplateResource(*itemplate, initiationInterval_);
        ResourceBroker::addResource(*itemplate, itemplateResource);
    }
 
    Machine::BusNavigator busNavi = target.busNavigator();
 
    for (int i = 0; i < busNavi.count(); i++) {
        slots_.push_back(busNavi.item(i));
    }
}

References ResourceBroker::addResource(), TTAMachine::Machine::busNavigator(), TTAMachine::Machine::Navigator< ComponentType >::count(), ResourceBroker::initiationInterval_, TTAMachine::Machine::instructionTemplateNavigator(), TTAMachine::Machine::Navigator< ComponentType >::item(), and slots_.

Here is the call graph for this function:

◆ clear()

void ITemplateBroker::clear ( )

overridevirtual

Clears all bookkeeping for the broker.

the RM can then be reused for another basic block.

Reimplemented from ResourceBroker.

Definition at line 976 of file ITemplateBroker.cc.

                       {
    ResourceBroker::clear();
    clearOldResources();
 
    for (std::map<int, TTAProgram::Instruction*>::iterator i =
             instructions_.begin(); i != instructions_.end(); i++) {
        std::map<int, bool>::iterator j = instructionsNotOwned_.find(i->first);
        // does not find => owns, delete.
        if (j == instructionsNotOwned_.end() || j->second == false) {
            delete i->second;
        }
    }
    instructions_.clear();
    instructionsNotOwned_.clear();
    immediateCycles_.clear();
    immediateValues_.clear();
}

References ResourceBroker::clear(), clearOldResources(), immediateCycles_, immediateValues_, instructions_, and instructionsNotOwned_.

Here is the call graph for this function:

◆ clearOldResources()

void ITemplateBroker::clearOldResources ( )

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

Definition at line 966 of file ITemplateBroker.cc.

                                   {
    oldParentInstruction_.clear();
}

References oldParentInstruction_.

Referenced by clear(), and SimpleBrokerDirector::clearOldResources().

◆ earliestCycle()

int ITemplateBroker::earliestCycle	(	int	cycle,
		const MoveNode &	node,
		const TTAMachine::Bus *	bus,
		const TTAMachine::FunctionUnit *	srcUnit,
		const TTAMachine::FunctionUnit *	dstUnit,
		int	immWriteCycle,
		const TTAMachine::ImmediateUnit *	immu,
		int	immRegIndex
	)		const

overridevirtual

Return the earliest cycle, starting from given cycle, where a resource of the type managed by this broker can be assigned to the given node.

Parameters

cycle	Cycle.
node	Node.

Returns: The earliest cycle, starting from given cycle, where a resource of the type managed by this broker can be assigned to the given node.

Implements ResourceBroker.

Definition at line 500 of file ITemplateBroker.cc.

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

References abortWithError.

◆ findITemplates()

SchedulingResourceSet ITemplateBroker::findITemplates	(	int	cycle,
		Moves &	moves,
		Immediates &	immediates
	)		const

private

Helper function, finds all templates that are applicable for current status of instruction and new node that needs to be added

Parameters

moves	A set of moves which has to fit into template
immediates	A set of immediates which has to fit into template

Returns: A set of instruction templates that supports current instruction plus new instruction

Note: The test for Moves is done by checking if a bus Move uses is not allocated by template for immediate move. Immediate slots are not relevant here.

Definition at line 738 of file ITemplateBroker.cc.

                                  {
 
    cycle = instructionIndex(cycle);
    SchedulingResourceSet result;
    Instruction* ins = NULL;
    // Read in content of instruction if there is something already
    // stored in given cycle
    if (MapTools::containsKey(instructions_, cycle)) {
        ins = MapTools::valueForKey<TTAProgram::Instruction*>(
            instructions_, cycle);
        for (int i = 0; i < ins->moveCount(); i++) {
            moves.push_back(ins->movePtr(i));
        }
        for (int i = 0; i < ins->immediateCount(); i++) {
            immediates.push_back(ins->immediatePtr(i));
        }
    }
 
    for (ResourceMap::const_iterator resIter = resMap_.begin();
        resIter != resMap_.end(); resIter++) {
        bool addResult = true;
        // bus resources (slots) are in dependent group 0
        // immediate resources are in group 1
        // trying to find template that has exactly same number or
        // higher number of immediate writes as instruction
        if ((*resIter).second->dependentResourceGroupCount() > 1 &&
            immediates.size() > static_cast<unsigned int>(
                (*resIter).second->dependentResourceCount(1))) {
            continue;
        }
 
        const InstructionTemplate& iTemplate =
            dynamic_cast<const InstructionTemplate&>(*(*resIter).first);
 
        // For each of already assigned immediate writes, template
        // has to have destination unit
        std::vector<const TTAMachine::ImmediateUnit*> unitWriten;
        for (unsigned int i = 0; i < immediates.size(); i++) {
            const ImmediateUnit& unit =
                immediates[i]->destination().immediateUnit();
            if (ContainerTools::containsValue(unitWriten, &unit)) {
                addResult = false;
                break;
            }
            // immediate and immediate units has correct width, this checks
            // if template can transport such a number of bits into the unit
            // it is possible to have template which transport less bits
            if (!iTemplate.isOneOfDestinations(unit)) {
                addResult = false;
                break;
            }
            // FIXME: hack to check if terminal is floating point value
            if (immediates[i]->value().value().width() > INT_WORD_SIZE &&
                (immediates[i]->value().value().width() >
                iTemplate.supportedWidth(unit))) {
                addResult = false;
                break;
            }
            // FIXME: instruction addresses hold reference to instruction
            // reference which computes the SimValue depending on target
            // instruction's address. So it is not possible to modify the
            // bit width of such SimValue
            if (immediates[i]->value().isInstructionAddress() &&
                !immediates[i]->value().isBasicBlockReference() &&
                !immediates[i]->value().isCodeSymbolReference()) {
 
                const AddressSpace& as =
                    *rm_->machine().controlUnit()->addressSpace();
                int requiredBitWidth = unit.extensionMode() == Machine::SIGN ?
                    MathTools::requiredBitsSigned(as.end()) :
                    MathTools::requiredBits(as.end());
                if (requiredBitWidth > iTemplate.supportedWidth(unit)) {
                    addResult = false;
                    break;
                }
            }
            // Ignore instruction addresses, based on destination mode
            // tests required bits of correct representation of SimValue
            if (!immediates[i]->value().isInstructionAddress() &&
                !immediates[i]->value().isBasicBlockReference() &&
                !immediates[i]->value().isCodeSymbolReference() &&
                unit.extensionMode() == Machine::ZERO &&
                MathTools::requiredBits(
                    immediates[i]->value().value().unsignedValue()) >
                        iTemplate.supportedWidth(unit)) {
                addResult = false;
                break;
            } 
            if (!immediates[i]->value().isInstructionAddress() &&
                !immediates[i]->value().isBasicBlockReference() &&
                !immediates[i]->value().isCodeSymbolReference() &&
                unit.extensionMode() == Machine::SIGN &&
                MathTools::requiredBitsSigned(
                    immediates[i]->value().value().intValue()) >
                        iTemplate.supportedWidth(unit)) {
                addResult = false;
                break;
            }
            
            if (immediates[i]->value().isCodeSymbolReference() &&
                immediates[i]->value().toString() == "_end") {
                
                AddressSpace* dataAS;
                try {
                    dataAS =
                        MachineInfo::defaultDataAddressSpace(rm_->machine());
                } catch (Exception&) {
                    assert(false && "No default data address space");
                }
                
                int requiredBitWidth = unit.extensionMode() == Machine::SIGN ?
                        MathTools::requiredBitsSigned(dataAS->end()):
                        MathTools::requiredBits(dataAS->end());
 
                if (requiredBitWidth > iTemplate.supportedWidth(unit)) {
                    addResult = false;
                    break;
                }
                
            } else if (immediates[i]->value().isBasicBlockReference() ||
                immediates[i]->value().isCodeSymbolReference()) {
 
                const AddressSpace& as
                        = *rm_->machine().controlUnit()->addressSpace();
                int requiredBitWidth = unit.extensionMode() == Machine::SIGN ? 
                    MathTools::requiredBitsSigned(SLongWord(as.end())) :
                    MathTools::requiredBits(as.end());
                
                if (requiredBitWidth > iTemplate.supportedWidth(unit)) {
                    addResult = false;
                    break;
                }
 
            }
 
            unitWriten.push_back(&unit);
        }
        // For each of moves already assigned template
        // should not use the bus for immediate transport or as 
        // a fixed NOP slot
        for (unsigned int i = 0; i < moves.size(); i++) {
            
            const bool isNOPSlot = false;
                
            SchedulingResource* bus =
                busBroker_.resourceOf(moves[i]->bus());
            if ((*resIter).second->hasDependentResource(*bus) ||
                isNOPSlot) {
                addResult = false;
                break;
            }
        }
        if (addResult) {
            result.insert(*(*resIter).second);
        }
    }
    result.sort();
    return result;
}

References TTAMachine::FunctionUnit::addressSpace(), assert, busBroker_, MapTools::containsKey(), ContainerTools::containsValue(), TTAMachine::Machine::controlUnit(), MachineInfo::defaultDataAddressSpace(), TTAMachine::AddressSpace::end(), TTAMachine::ImmediateUnit::extensionMode(), TTAProgram::Instruction::immediateCount(), TTAProgram::Instruction::immediatePtr(), SchedulingResourceSet::insert(), ResourceBroker::instructionIndex(), instructions_, INT_WORD_SIZE, TTAMachine::InstructionTemplate::isOneOfDestinations(), MapTools::keyForValue(), ResourceManager::machine(), TTAProgram::Instruction::moveCount(), TTAProgram::Instruction::movePtr(), MathTools::requiredBits(), MathTools::requiredBitsSigned(), ResourceBroker::resMap_, ResourceBroker::resourceOf(), rm_, TTAMachine::Machine::SIGN, SchedulingResourceSet::sort(), TTAMachine::InstructionTemplate::supportedWidth(), and TTAMachine::Machine::ZERO.

Referenced by allAvailableResources(), assignImmediate(), instruction(), isTemplateAvailable(), and reselectTemplate().

Here is the call graph for this function:

◆ instruction()

TTAProgram::Instruction * ITemplateBroker::instruction ( int cycle )

virtual

Returns an instruction at a given cycle.

Parameters

cycle Cycle for which to return instruction

Returns: an instruction object for given cycle, empty instruction if there is no record.

Definition at line 693 of file ITemplateBroker.cc.

                                      {
    cycle = instructionIndex(cycle);
    if (!MapTools::containsKey(instructions_, cycle)) {
        Moves moves;
        Immediates immediates;
        SchedulingResourceSet defaultTemplates = findITemplates(
            cycle, moves, immediates);
        if (defaultTemplates.count() == 0) {
            throw InvalidData(
                __FILE__, __LINE__, __func__,
                "No Instruction Template available!");
        }
        SchedulingResource& iTemp = defaultTemplates.resource(0);
        const MachinePart& mp = machinePartOf(iTemp);
        const InstructionTemplate& iTemplate =
                dynamic_cast<const InstructionTemplate&>(mp);
        ITemplateResource& templateRes =
                dynamic_cast<ITemplateResource&>(iTemp);
        templateRes.assign(cycle);
        TTAProgram::Instruction* ins = NULL;
        ins = new TTAProgram::Instruction(iTemplate);
        instructions_[cycle] = ins;
        ins->setInstructionTemplate(iTemplate);
        return ins;
    }
    Instruction* ins =
        MapTools::valueForKey<TTAProgram::Instruction*>(
            instructions_, cycle);
    return ins;
}

References __func__, ITemplateResource::assign(), MapTools::containsKey(), SchedulingResourceSet::count(), findITemplates(), ResourceBroker::instructionIndex(), instructions_, MapTools::keyForValue(), ResourceBroker::machinePartOf(), SchedulingResourceSet::resource(), and TTAProgram::Instruction::setInstructionTemplate().

Referenced by SimpleBrokerDirector::instruction().

Here is the call graph for this function:

◆ isAlreadyAssigned()

bool ITemplateBroker::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 544 of file ITemplateBroker.cc.

                                                                 {
    if (node.isImmediate()) {
        return node.immediate().parent() != NULL;
    }
    Move& move = const_cast<MoveNode&>(node).move();
 
    cycle = instructionIndex(cycle);
    if (!move.isInInstruction()) {
        return false;
    }
    const InstructionTemplate& iTemplate =
        move.parent().instructionTemplate();
 
    // Cannot be already assigned if template is null.
    if (&iTemplate != &NullInstructionTemplate::instance()) {
        // When node is assigned, it's old parent is stored, thus if the
        // old parent is stored, node was assigned
        if (MapTools::containsKey(oldParentInstruction_, &node)) {
            SchedulingResource* res = resourceOf(iTemplate);
            if ( res != NULL && res->isInUse(cycle)) {
                return true;
            }
        }
    }
    return false;
}

References MapTools::containsKey(), MoveNode::immediate(), TTAMachine::NullInstructionTemplate::instance(), ResourceBroker::instructionIndex(), TTAProgram::Instruction::instructionTemplate(), MoveNode::isImmediate(), TTAProgram::Move::isInInstruction(), SchedulingResource::isInUse(), oldParentInstruction_, TTAProgram::Immediate::parent(), TTAProgram::Move::parent(), and ResourceBroker::resourceOf().

Here is the call graph for this function:

◆ isAnyResourceAvailable()

bool ITemplateBroker::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

overridevirtual

Return true if there's an instruction template available to be used on the given cycle for the given move.

If the given node contains a long immediate register read, the instruction template must be able to encode required bits for it.

Parameters

cycle	Cycle where instruction template is used.
node	Node which contains long immediate register read.

Returns: True if there's an instruction template available to be used on the given cycle, and the template is able to encode bits for long immediate that is read in given node.

Reimplemented from ResourceBroker.

Definition at line 115 of file ITemplateBroker.cc.

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

References allAvailableResources(), and ResourceBroker::instructionIndex().

Here is the call graph for this function:

◆ isApplicable()

bool ITemplateBroker::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: True if the given node needs a resource of the type managed by this broker, false otherwise.

Todo:: reconsider, should be applicable for all the MoveNodes

Implements ResourceBroker.

Definition at line 582 of file ITemplateBroker.cc.

                                                                         {
    return true;
}

◆ isImmediateInTemplate()

bool ITemplateBroker::isImmediateInTemplate	(	int	defCycle,
		std::shared_ptr< TTAProgram::Immediate >	imm
	)		const

private

Definition at line 920 of file ITemplateBroker.cc.

                                        {
 
    if (!MapTools::containsKey(instructions_, defCycle)) {
        return false;
    }
    Instruction* ins =  MapTools::valueForKey<TTAProgram::Instruction*>(
        instructions_, defCycle);
    for (int i = 0; i < ins->immediateCount(); i++){
        if (ins->immediate(i).value().value() == imm->value().value() &&
            ins->immediate(i).destination().equals(imm->destination())){
            return true;
        }
    }
    return false;
}

References MapTools::containsKey(), TTAProgram::Immediate::destination(), TTAProgram::Terminal::equals(), TTAProgram::Instruction::immediate(), TTAProgram::Instruction::immediateCount(), instructions_, MapTools::keyForValue(), TTAProgram::Immediate::value(), and TTAProgram::TerminalImmediate::value().

Referenced by assign(), and unassign().

Here is the call graph for this function:

◆ isITemplateBroker()

bool ITemplateBroker::isITemplateBroker ( ) const

overridevirtual

Return true always.

Returns: True always.

Reimplemented from ResourceBroker.

Definition at line 681 of file ITemplateBroker.cc.

                                         {
    return true;
}

◆ isTemplateAvailable()

bool ITemplateBroker::isTemplateAvailable	(	int	defCycle,
		std::shared_ptr< TTAProgram::Immediate >	immediate
	)		const

virtual

Tests if there is any instruction template available for immediate in given cycle

Parameters

defCycle	cycle to test
immediate	Immediate to test

Returns: True if there is instruction template for given cycle which can write given immediate

Definition at line 948 of file ITemplateBroker.cc.

                                              {
 
    Immediates immediates;
    Moves moves;
    immediates.push_back(immediate);
    int availableCount =
        findITemplates(defCycle, moves, immediates).count();
    return availableCount > 0;
}

References SchedulingResourceSet::count(), and findITemplates().

Referenced by SimpleBrokerDirector::isTemplateAvailable().

Here is the call graph for this function:

◆ latestCycle()

int ITemplateBroker::latestCycle	(	int	cycle,
		const MoveNode &	node,
		const TTAMachine::Bus *	bus,
		const TTAMachine::FunctionUnit *	srcUnit,
		const TTAMachine::FunctionUnit *	dstUnit,
		int	immWriteCycle,
		const TTAMachine::ImmediateUnit *	immu,
		int	immRegIndex
	)		const

overridevirtual

Return the latest cycle, starting from given cycle, where a resource of the type managed by this broker can be assigned to the given node.

Parameters

cycle	Cycle.
node	Node.

Returns: The latest cycle, starting from given cycle, where a resource of the type managed by this broker can be assigned to the given node.

Implements ResourceBroker.

Definition at line 521 of file ITemplateBroker.cc.

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

References abortWithError.

◆ loseInstructionOwnership()

void ITemplateBroker::loseInstructionOwnership ( int cycle )

virtual

Transfer the instruction ownership away from this object,

If this method is called, resource manager does not delete it's instructions when it it destroyed.

Definition at line 908 of file ITemplateBroker.cc.

                                                   {
    instructionsNotOwned_[cycle] = true;
}

References instructionsNotOwned_.

Referenced by SimpleBrokerDirector::loseInstructionOwnership().

◆ reselectTemplate()

void ITemplateBroker::reselectTemplate	(	TTAProgram::Instruction &	ins,
		int	cycle
	)

private

Reselect the template to be the most optimal (most nop slots etc) Called always on unassign.

Definition at line 470 of file ITemplateBroker.cc.

                                                                       {
    // set new template that does not use immediate slot just unassigned
    // moves and immediate will be filled from instruction in given cycle
    // inside findITTemplates method
    Moves moves;
    Immediates immediates;
    const SchedulingResourceSet& resources = 
        findITemplates(cycle, moves, immediates);
    assert(resources.count() >0);
    ITemplateResource& newTemplateRes = static_cast<ITemplateResource&>(
        resources.resource(0));
     const InstructionTemplate& newTemplate =
        dynamic_cast<const InstructionTemplate&>(
            machinePartOf(newTemplateRes));
    ins.setInstructionTemplate(newTemplate);
    newTemplateRes.assign(cycle);
}

References assert, ITemplateResource::assign(), findITemplates(), ResourceBroker::machinePartOf(), ResourceBroker::resources(), and TTAProgram::Instruction::setInstructionTemplate().

Referenced by unassign(), and unassignImmediate().

Here is the call graph for this function:

◆ setupResourceLinks()

void ITemplateBroker::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 625 of file ITemplateBroker.cc.

                                                                {
 
    setResourceMapper(mapper);
 
    for (ResourceMap::iterator resIter = resMap_.begin();
         resIter != resMap_.end(); resIter++) {
 
        const InstructionTemplate* itemplate =
            dynamic_cast<const InstructionTemplate*>((*resIter).first);
        if (itemplate == NULL){
            throw InvalidData(
                __FILE__, __LINE__, __func__,
                "Broker does not have necessary Template registered!");
        }
 
        SchedulingResource* templateResource = (*resIter).second;
 
        for (unsigned int i = 0; i < slots_.size(); i++) {
            if (itemplate->usesSlot(slots_[i]->name())) {
                try {
                    SchedulingResource& depSlot =
                        mapper.resourceOf(*slots_[i]);
                    templateResource->addToDependentGroup(0, depSlot);
                } catch (const KeyNotFound& e) {
                    std::string msg = "ITemplateBroker: finding ";
                    msg += " resource for Slot ";
                    msg += " failed with error: ";
                    msg += e.errorMessageStack();
                    throw KeyNotFound(
                        __FILE__, __LINE__, __func__, msg);
                }
 
                ImmediateUnit* iu =
                    itemplate->destinationOfSlot(slots_[i]->name());
                try {
                    SchedulingResource& depIU = mapper.resourceOf(*iu);
                    templateResource->addToDependentGroup(1, depIU);
                } catch (const KeyNotFound& e) {
                    std::string msg = "ITemplateBroker: finding ";
                    msg += " resource for IU ";
                    msg += " failed with error: ";
                    msg += e.errorMessageStack();
                    throw KeyNotFound(
                        __FILE__, __LINE__, __func__, msg);
                }
            }
        }
    }
}

References __func__, SchedulingResource::addToDependentGroup(), TTAMachine::InstructionTemplate::destinationOfSlot(), Exception::errorMessageStack(), ResourceBroker::resMap_, ResourceMapper::resourceOf(), ResourceBroker::setResourceMapper(), slots_, and TTAMachine::InstructionTemplate::usesSlot().

Here is the call graph for this function:

◆ unassign()

void ITemplateBroker::unassign ( MoveNode & node )

overridevirtual

Free the instruction template resource used in the parent instruction of the given node.

Parameters

node Node.

Note: Returns ownership of Move in MoveNode to the original parent instruction

Implements ResourceBroker.

Definition at line 381 of file ITemplateBroker.cc.

                                        {
    // Template not to be unassgined, it is just that there will be space
    // left in this template for move
 
    TTAProgram::Instruction& ins = node.isMove() ? node.move().parent() :
        *node.immediate().parent();
    if (MapTools::containsKey(oldParentInstruction_, &node)) {
        if (node.isMove()) {
            ins.removeMove(node.move());
            TTAProgram::Instruction* oldParent =
                MapTools::valueForKey<TTAProgram::Instruction*>(
                    oldParentInstruction_, &node);
            if (oldParent != NULL) {
                oldParent->addMove(node.movePtr());
            }
            oldParentInstruction_.erase(&node);
        } else if (node.isImmediate()) {
            ins.removeImmediate(node.immediate());
            TTAProgram::Instruction* oldParent =
                MapTools::valueForKey<TTAProgram::Instruction*>(
                    oldParentInstruction_, &node);
            if (oldParent != NULL) {
                oldParent->addImmediate(node.immediatePtr());
            }
            oldParentInstruction_.erase(&node);
            reselectTemplate(ins, node.cycle());
            return;
        }
    }
    if (node.isSourceConstant() &&
        MapTools::containsKey(immediateCycles_, &node)) {
        int defCycle = MapTools::valueForKey<int>(immediateCycles_, &node);
        auto imm =
            MapTools::valueForKey<std::shared_ptr<TTAProgram::Immediate> >(
                immediateValues_, &node);
 
        if (isImmediateInTemplate(defCycle, imm)) {
            unassignImmediate(defCycle, imm->destination().immediateUnit());
        } else {
            abortWithError("Failed to remove Immediate from instruction");
        }
        immediateCycles_.erase(&node);
        immediateValues_.erase(&node);
    }
    reselectTemplate(ins, node.cycle());
}

References abortWithError, TTAProgram::Instruction::addImmediate(), TTAProgram::Instruction::addMove(), MapTools::containsKey(), MoveNode::cycle(), MoveNode::immediate(), immediateCycles_, MoveNode::immediatePtr(), immediateValues_, MoveNode::isImmediate(), isImmediateInTemplate(), MoveNode::isMove(), MoveNode::isSourceConstant(), MapTools::keyForValue(), MoveNode::move(), MoveNode::movePtr(), oldParentInstruction_, TTAProgram::Immediate::parent(), TTAProgram::Move::parent(), TTAProgram::Instruction::removeImmediate(), TTAProgram::Instruction::removeMove(), reselectTemplate(), and unassignImmediate().

Here is the call graph for this function:

◆ unassignImmediate()

void ITemplateBroker::unassignImmediate	(	int	cycle,
		const TTAMachine::ImmediateUnit &	immediateUnit
	)

private

Free the Instruction template used at this cycle. Sets new instruction template that does not use freed immediate slot.

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

cycle	Cycle from where to unassign immediate
immediate	Immediate to remove from cycle

Definition at line 440 of file ITemplateBroker.cc.

                                        {
    cycle = instructionIndex(cycle);
 
    if (!MapTools::containsKey(instructions_, cycle)) {
        return;
    }
    Instruction* ins =
        MapTools::valueForKey<Instruction*>(instructions_, cycle);
    const InstructionTemplate& iTemplate = ins->instructionTemplate();
    SchedulingResource& res = *resourceOf(iTemplate);
    ITemplateResource& templateRes = dynamic_cast<ITemplateResource&>(res);
 
    templateRes.unassign(cycle);
    for (int i = 0; i < ins->immediateCount(); i++) {
        if (ins->immediate(i).destination().immediateUnit().name() ==
            immediateUnit.name()) {
            ins->removeImmediate(ins->immediate(i));
            break;
        }
    }
    reselectTemplate(*ins, cycle);
}

References MapTools::containsKey(), TTAProgram::Immediate::destination(), TTAProgram::Instruction::immediate(), TTAProgram::Instruction::immediateCount(), TTAProgram::Terminal::immediateUnit(), ResourceBroker::instructionIndex(), instructions_, TTAProgram::Instruction::instructionTemplate(), MapTools::keyForValue(), TTAMachine::Component::name(), TTAProgram::Instruction::removeImmediate(), reselectTemplate(), ResourceBroker::resourceOf(), and ITemplateResource::unassign().

Referenced by unassign().

Here is the call graph for this function:

Member Data Documentation

◆ busBroker_

BusBroker& ITemplateBroker::busBroker_

private

Definition at line 153 of file ITemplateBroker.hh.

Referenced by findITemplates().

◆ immediateCycles_

std::map<const MoveNode*, int, GraphNode::Comparator> ITemplateBroker::immediateCycles_

private

Record cycle for MoveNodes that needed immediate writes, IU broker restores immediates before the template broker is called so we need to explicitely find the Immediate to remove it from template.

Definition at line 144 of file ITemplateBroker.hh.

Referenced by assign(), clear(), and unassign().

◆ immediateValues_

std::map<const MoveNode*, std::shared_ptr<TTAProgram::Immediate>, GraphNode::Comparator> ITemplateBroker::immediateValues_

private

Definition at line 146 of file ITemplateBroker.hh.

Referenced by assign(), clear(), and unassign().

◆ instructions_

std::map<int, TTAProgram::Instruction*> ITemplateBroker::instructions_

private

cycle/instruction

Definition at line 135 of file ITemplateBroker.hh.

Referenced by assign(), assignImmediate(), clear(), findITemplates(), instruction(), isImmediateInTemplate(), unassignImmediate(), and ~ITemplateBroker().

◆ instructionsNotOwned_

std::map<int, bool> ITemplateBroker::instructionsNotOwned_

private

Definition at line 148 of file ITemplateBroker.hh.

Referenced by clear(), loseInstructionOwnership(), and ~ITemplateBroker().

◆ oldParentInstruction_

std::map<const MoveNode*, TTAProgram::Instruction*, MoveNode::Comparator> ITemplateBroker::oldParentInstruction_

private

MoveNode/ original parent instruction.

Definition at line 138 of file ITemplateBroker.hh.

Referenced by assign(), clearOldResources(), isAlreadyAssigned(), and unassign().

◆ rm_

SimpleResourceManager* ITemplateBroker::rm_

private

Definition at line 152 of file ITemplateBroker.hh.

Referenced by assign(), and findITemplates().

◆ slots_

std::vector<TTAMachine::Bus*> ITemplateBroker::slots_

private

Move/immediate slots.

Definition at line 133 of file ITemplateBroker.hh.

Referenced by buildResources(), and setupResourceLinks().

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

◆ Immediates

◆ Moves

Constructor & Destructor Documentation

◆ ITemplateBroker() [1/2]

◆ ITemplateBroker() [2/2]

◆ ~ITemplateBroker()

Member Function Documentation

◆ allAvailableResources()

◆ assign()

◆ assignImmediate()

◆ buildResources()

◆ clear()

◆ clearOldResources()

◆ earliestCycle()

◆ findITemplates()

◆ instruction()

◆ isAlreadyAssigned()

◆ isAnyResourceAvailable()

◆ isApplicable()

◆ isImmediateInTemplate()

◆ isITemplateBroker()

◆ isTemplateAvailable()

◆ latestCycle()

◆ loseInstructionOwnership()

◆ reselectTemplate()

◆ setupResourceLinks()

◆ unassign()

◆ unassignImmediate()

Member Data Documentation

◆ busBroker_

◆ immediateCycles_

◆ immediateValues_

◆ instructions_

◆ instructionsNotOwned_

◆ oldParentInstruction_

◆ rm_

◆ slots_