#include <IUResource.hh>

Inheritance diagram for IUResource:

Collaboration diagram for IUResource:

Classes
struct	ResourceRecordType

Public Member Functions
virtual	~IUResource ()

	IUResource (const TTAMachine::Machine &mach, const std::string &name, const int registers, const int width, const int latency, const bool signExtension, unsigned int initiationInterval=0)

virtual bool	isInUse (const int cycle) const override

virtual bool	isAvailable (const int cycle, int immRegIndex) const

virtual bool	isAvailable (const int cycle) const override

virtual bool	canAssign (const int, const MoveNode &) const override

virtual bool	canAssign (const int defCycle, const int useCycle, const MoveNode &node, int immRegIndex) const

virtual void	assign (const int cycle, MoveNode &node) override

virtual void	assign (const int defCycle, const int useCycle, MoveNode &node, int &index)

virtual void	unassign (const int cycle, MoveNode &node) override

virtual bool	isIUResource () const override

int	registerCount () const

std::shared_ptr< TTAProgram::TerminalImmediate >	immediateValue (const MoveNode &node) const

int	immediateWriteCycle (const MoveNode &node) const

int	width () const

void	clearOldResources ()

void	clear () override

Public Member Functions inherited from SchedulingResource
virtual	~SchedulingResource ()

	SchedulingResource (const std::string &name, const unsigned int ii=0)

virtual int	relatedResourceGroupCount () const

virtual int	dependentResourceGroupCount () const

int	relatedResourceCount (const int group) const

int	dependentResourceCount (const int group) const

virtual void	addToRelatedGroup (const int group, SchedulingResource &resource)

virtual void	addToDependentGroup (const int group, SchedulingResource &resource)

virtual SchedulingResource &	relatedResource (const int group, const int index) const

virtual SchedulingResource &	dependentResource (const int group, const int index) const

virtual bool	hasRelatedResource (const SchedulingResource &sResource) const

virtual bool	hasDependentResource (const SchedulingResource &sResource) const

virtual const std::string &	name () const

virtual int	useCount () const

virtual void	increaseUseCount ()

virtual void	decreaseUseCount ()

virtual bool	isInputPSocketResource () const

virtual bool	isOutputPSocketResource () const

virtual bool	isShortImmPSocketResource () const

virtual bool	isInputFUResource () const

virtual bool	isOutputFUResource () const

virtual bool	isExecutionPipelineResource () const

virtual bool	isBusResource () const

virtual bool	isSegmentResource () const

virtual bool	isITemplateResource () const

int	instructionIndex (int cycle) const

void	setInitiationInterval (unsigned int ii)

int	initiationInterval () const

virtual bool	operator< (const SchedulingResource &other) const

virtual void	setMaxCycle (unsigned int)

Protected Member Functions
virtual bool	validateDependentGroups () override

virtual bool	validateRelatedGroups () override

void	setRegisterCount (const int registers)

Private Types
typedef std::vector< ResourceRecordType * >	ResourceRecordVectorType

Private Member Functions
bool	canAssignUse (int useCycle) const

	IUResource (const IUResource &)

IUResource &	operator= (const IUResource &)

int	findAvailable (const int defCycle, const int useCycle, int immRegIndex) const

Private Attributes
std::vector< ResourceRecordVectorType >	resourceRecord_

int	registerCount_

int	width_

int	latency_

bool	signExtension_

const TTAMachine::Machine &	machine_

Additional Inherited Members
Protected Attributes inherited from SchedulingResource
int	initiationInterval_

Detailed Description

An interface for scheduling resources of Resource Model The derived class IUResource

Definition at line 56 of file IUResource.hh.

Member Typedef Documentation

◆ ResourceRecordVectorType

typedef std::vector<ResourceRecordType*> IUResource::ResourceRecordVectorType

private

Definition at line 115 of file IUResource.hh.

Constructor & Destructor Documentation

◆ ~IUResource()

IUResource::~IUResource ( )

virtual

Empty destructor

Definition at line 74 of file IUResource.cc.

                        {
    for (int i = 0; i < registerCount(); i++) {
        SequenceTools::deleteAllItems(resourceRecord_.at(i));
    }
}

References SequenceTools::deleteAllItems(), registerCount(), and resourceRecord_.

Here is the call graph for this function:

◆ IUResource() [1/2]

IUResource::IUResource	(	const TTAMachine::Machine &	mach,
		const std::string &	name,
		const int	registers,
		const int	width,
		const int	latency,
		const bool	signExtension,
		unsigned int	initiationInterval = `0`
	)

Constructor defining resource name, register count and register width

Parameters

name	Name of resource
registers	Number of registers in IU
width	Bit width of registers in immediate unit
latency	Latency of Immediate unit, defaults to 1 in TCE
signExtension	Indicates if IU is using Zero or Sign extend

Definition at line 54 of file IUResource.cc.

    : SchedulingResource(name, initiationInterval),
      registerCount_(registers), width_(width),
      latency_(latency) , signExtension_(signExtension), machine_(mach) {
    for (int i = 0; i < registerCount(); i++) {
        ResourceRecordVectorType vt;
        resourceRecord_.push_back(vt);
    }
}

References registerCount(), and resourceRecord_.

Here is the call graph for this function:

◆ IUResource() [2/2]

IUResource::IUResource ( const IUResource & )

private

Member Function Documentation

◆ assign() [1/2]

void IUResource::assign	(	const int	cycle,
		MoveNode &	mn
	)

overridevirtual

Implementation of abstract method from base class. IUResource requires different api (definition and use cycle) This method is not to be used!

Implements SchedulingResource.

Definition at line 175 of file IUResource.cc.

                                                {
 
    assert(mn.move().source().isImmediateRegister());
    int index = mn.move().source().index();
    ResourceRecordType* rc =
        new ResourceRecordType(
            -1,cycle,nullptr);
 
    resourceRecord_.at(index).push_back(rc);
    return;
    std::string msg = "IUResource: called assign with \'cycle\'";
    msg += " and \'node\'. Use assign with \'defCycle\',";
    msg += " \'useCycle\', \'node\' and \'index\' reference!";
    abortWithError(msg);
}

References abortWithError, assert, TTAProgram::Terminal::index(), TTAProgram::Terminal::isImmediateRegister(), MoveNode::move(), resourceRecord_, and TTAProgram::Move::source().

Referenced by IUBroker::assign().

Here is the call graph for this function:

◆ assign() [2/2]

void IUResource::assign	(	const int	defCycle,
		const int	useCycle,
		MoveNode &	node,
		int &	index
	)

virtual

Assign resource to given node for given cycle

Parameters

defCycle	Cycle in which the value of immediate register will be written using instruction template
useCycle	Cycle in which the value of immediate register will be read by MoveNode
node	MoveNode that reads the immediate register
index	Will be used to return index of register assigned

Definition at line 201 of file IUResource.cc.

                                                                        {
 
    if (defCycle > useCycle) {
        std::string msg =
            "Long immediate definition cycle later than use cycle: ";
        msg += Conversion::toString(defCycle);
        msg += " > ";
        msg += Conversion::toString(useCycle);
        msg += "!";
        throw ModuleRunTimeError(__FILE__, __LINE__, __func__, msg);
    }
    if ((useCycle - defCycle) < latency_) {
        std::string msg = "Definition and use too close(";
        msg += Conversion::toString(useCycle - defCycle) + "). ";
        msg += name() + " has latency of " + Conversion::toString(latency_);
        throw ModuleRunTimeError(__FILE__, __LINE__, __func__, msg);
    }
    int i = findAvailable(defCycle, useCycle, index);
    if (i != -1) {
        index = i;
        ResourceRecordType* rc =
            new ResourceRecordType(
                defCycle,useCycle,static_cast<TTAProgram::TerminalImmediate*>(
                    node.move().source().copy()));
        resourceRecord_.at(i).push_back(rc);
        return;
    }
    std::string msg = "Assignment for immediate impossible!";
    throw KeyNotFound(__FILE__, __LINE__, __func__, msg);
}

References __func__, TTAProgram::Terminal::copy(), findAvailable(), latency_, MoveNode::move(), SchedulingResource::name(), resourceRecord_, TTAProgram::Move::source(), and Conversion::toString().

Here is the call graph for this function:

◆ canAssign() [1/2]

bool IUResource::canAssign	(	const int	defCycle,
		const int	useCycle,
		const MoveNode &	node,
		int	immRegIndex
	)		const

virtual

Return true if resource can be assigned for given resource in given cycle

Parameters

defCycle	definition cycle
useCycle	use of register cycle
node	MoveNode to test

Returns: true if node can be assigned to cycle

Definition at line 321 of file IUResource.cc.

                           {
 
    if (defCycle > useCycle) {
        return false;
    }
    if ((useCycle - defCycle) < latency_) {
        return false;
    }
 
    MoveNode& mNode = const_cast<MoveNode&>(node);
    if (!mNode.move().source().isImmediate()) {
        return false;
    }
 
    TTAProgram::TerminalImmediate* iTerm =
        static_cast<TTAProgram::TerminalImmediate*>(&mNode.move().source());
    if (findAvailable(defCycle, useCycle, immRegIndex) != -1) {
        int reqWidth = MachineConnectivityCheck::requiredImmediateWidth(
            signExtension_, *iTerm, machine_);
        if (reqWidth > width_) {
            return false;
        }
 
        for (int i = 0; i < relatedResourceGroupCount(); i++) {
            for (int j = 0, count = relatedResourceCount(i); j < count; j++) {
                SchedulingResource& relRes = relatedResource(i,j);
                // related res is  counted as modcycles.
                if (relRes.isOutputPSocketResource()) {
                    if (!relRes.isInUse(instructionIndex(useCycle))) {
                        return true;
                    } 
                }
            }
        }
    }
    return false;
}

References findAvailable(), SchedulingResource::instructionIndex(), TTAProgram::Terminal::isImmediate(), SchedulingResource::isInUse(), SchedulingResource::isOutputPSocketResource(), latency_, machine_, MoveNode::move(), SchedulingResource::relatedResource(), SchedulingResource::relatedResourceCount(), SchedulingResource::relatedResourceGroupCount(), MachineConnectivityCheck::requiredImmediateWidth(), signExtension_, TTAProgram::Move::source(), and width_.

Here is the call graph for this function:

◆ canAssign() [2/2]

bool IUResource::canAssign	(	const int	cycle,
		const MoveNode &	mn
	)		const

overridevirtual

Implementation of abstract method from base class. IUResource requires different api (definition and use cycle) This method is not to be used!

Implements SchedulingResource.

Definition at line 282 of file IUResource.cc.

                                                               {
    if (mn.isMove()) {
        return canAssignUse(cycle);
    }
    std::string msg = "IUResource: called canAssign with \'cycle\'";
    msg += " and \'node\'. Use canAssign with \'defCycle\',";
    msg += " \'useCycle\' and \'node\'!";
    abortWithError(msg);
    return false;
}

References abortWithError, canAssignUse(), and MoveNode::isMove().

Referenced by IUBroker::allAvailableResources(), and IUBroker::assign().

Here is the call graph for this function:

◆ canAssignUse()

bool IUResource::canAssignUse ( int useCycle ) const

private

Checks that a immediate value can be read in the given cycle

Definition at line 297 of file IUResource.cc.

                                           {
    for (int i = 0; i < relatedResourceGroupCount(); i++) {
        for (int j = 0, count = relatedResourceCount(i); j < count; j++) {
            SchedulingResource& relRes = relatedResource(i,j);
            // related res is  counted as modcycles.
            if (relRes.isOutputPSocketResource()) {
                if (!relRes.isInUse(instructionIndex(useCycle))) {
                    return true;
                }
            }
        }
    }
    return false;
}

References SchedulingResource::instructionIndex(), SchedulingResource::isInUse(), SchedulingResource::isOutputPSocketResource(), SchedulingResource::relatedResource(), SchedulingResource::relatedResourceCount(), and SchedulingResource::relatedResourceGroupCount().

Referenced by canAssign().

Here is the call graph for this function:

◆ clear()

void IUResource::clear ( )

overridevirtual

Clears bookkeeping of the scheduling resource.

After this call the state of the resource should be identical to a newly-created and initialized resource.

Reimplemented from SchedulingResource.

Definition at line 587 of file IUResource.cc.

                  {
    SchedulingResource::clear();
    for (int i = 0; i < registerCount(); i++) {
        SequenceTools::deleteAllItems(resourceRecord_.at(i));
    }
}

References SchedulingResource::clear(), SequenceTools::deleteAllItems(), registerCount(), and resourceRecord_.

Here is the call graph for this function:

◆ clearOldResources()

void IUResource::clearOldResources ( )

Definition at line 560 of file IUResource.cc.

                              {
    for (int i = 0; i < registerCount(); i++) {
        for (int j = 0; 
             j < static_cast<int>(resourceRecord_.at(i).size()); j++) {
            ResourceRecordType* rec = resourceRecord_.at(i).at(j);
            rec->immediateValue_ = NULL;
        }
    }
}

References IUResource::ResourceRecordType::immediateValue_, registerCount(), and resourceRecord_.

Referenced by IUBroker::clearOldResources().

Here is the call graph for this function:

◆ findAvailable()

int IUResource::findAvailable	(	const int	defCycle,
		const int	useCycle,
		int	immRegIndex
	)		const

private

Internal helper method, find available register for given pair of definition and use cycles.

Definition at line 491 of file IUResource.cc.

                                                                   {
    int modDef = instructionIndex(defCycle + latency_);
    int modUse = instructionIndex(useCycle);
    for (int i = 0; i < registerCount(); i++) {
        if (immRegIndex != -1 && i != immRegIndex) continue;
        bool marker = false;
        const ResourceRecordVectorType& resVec = resourceRecord_.at(i);
        int size = resVec.size();
        for (int j = 0; j < size; j++) {
            int otherDef = resVec[j]->definition_;
            int modOtherDef = instructionIndex(otherDef + latency_);
            int otherUse = resVec[j]->use_;
            int modOtherUse = instructionIndex(otherUse);
            
            // no overlap in old.
            if (modOtherUse >= modOtherDef) {
                // ordinary comparison, use between old def and use?
                if (modUse >= modOtherDef && modUse <= modOtherUse) {
                    marker = true;
                    break;
                }
                
                if (modDef >= modOtherDef && modDef <= modOtherUse) {
                    marker = true;
                    break;
                }
 
            } else { 
                // before use before use, or after def of other
                if (modUse >= modOtherDef || modUse <= modOtherUse) {
                    marker = true;
                    break;
                }
                
                if (modDef >= modOtherDef || modDef <= modOtherUse) {
                    marker = true;
                    break;
                }
            }
 
            // other def between these. case when other completely
            // iside this range. can be detected be either other
            // use or other def. checks above handle cases where
            // tries to def, def, use, use
 
            if (modDef <= modUse) {
                // no overlap in this. ordinary check.
                if (modOtherDef >= modDef && modOtherDef <= modUse) {
                    marker = true;
                    break;
                }
            } else {
                // we have overlap.
 
                if (modOtherDef >= modDef || modOtherDef <= modUse) {
                    marker = true;
                    break;
                }
            }
        }
        if (marker == false) {
            return i;
        }
    }
    return -1;
}

References SchedulingResource::instructionIndex(), latency_, registerCount(), and resourceRecord_.

Referenced by assign(), and canAssign().

Here is the call graph for this function:

◆ immediateValue()

std::shared_ptr< TTAProgram::TerminalImmediate > IUResource::immediateValue ( const MoveNode & node ) const

Returns a constant that should be written to immediate register used by MoveNode in cycle

Parameters

cycle	Cycle in which immediate register is read
node	MoveNode which is reading the register

Returns: Long immediate constant that is expected to be in register

Definition at line 407 of file IUResource.cc.

                                                     {
    MoveNode& testNode = const_cast<MoveNode&>(node);
    if (!testNode.move().source().isImmediateRegister()) {
        std::string msg = "Immediate register was not assigned!";
        throw KeyNotFound(__FILE__, __LINE__, __func__, msg);
    }
    int regIndex = testNode.move().source().index();
    for (int j = 0;
        j < static_cast<int>(resourceRecord_.at(regIndex).size());
        j++) {
        if (node.cycle() == resourceRecord_.at(regIndex).at(j)->use_) {
            // Test if cycle equal to use of value
            // for register, if it is we return original terminal
            return resourceRecord_.at(regIndex).at(j)->immediateValue_;
        }
    }
    std::string msg = "Immediate register was not recorded in resource!";
    throw KeyNotFound(__FILE__, __LINE__, __func__, msg);
}

References __func__, MoveNode::cycle(), TTAProgram::Terminal::index(), TTAProgram::Terminal::isImmediateRegister(), MoveNode::move(), resourceRecord_, and TTAProgram::Move::source().

Referenced by IUBroker::immediateValue(), and IUBroker::isAlreadyAssigned().

Here is the call graph for this function:

◆ immediateWriteCycle()

int IUResource::immediateWriteCycle ( const MoveNode & node ) const

Returns a cycle in which immediate register used by MoveNode is written

Parameters

node	MoveNode which is reading the register

Returns: cycle in which register is written, or -1 if not found.

Definition at line 433 of file IUResource.cc.

                                                          {
 
    MoveNode& testNode = const_cast<MoveNode&>(node);
    if (!testNode.move().source().isImmediateRegister()) {
    return -1;
        //std::string msg = "Immediate register was not assigned!";
        //throw KeyNotFound(__FILE__, __LINE__, __func__, msg);
    }
    int regIndex = testNode.move().source().index();
    for (int j = 0;
        j < static_cast<int>(resourceRecord_.at(regIndex).size());
        j++) {
        if (node.cycle() == resourceRecord_.at(regIndex).at(j)->use_) {
            // Test if cycle equal to use of value
            // for register, if it is we return definition cycle
            return resourceRecord_.at(regIndex).at(j)->definition_;
        }
    }
    return -1;
    //std::string msg = "Immediate register was not recorded in resource!";
    //throw KeyNotFound(__FILE__, __LINE__, __func__, msg);
}

References MoveNode::cycle(), TTAProgram::Terminal::index(), TTAProgram::Terminal::isImmediateRegister(), MoveNode::move(), resourceRecord_, and TTAProgram::Move::source().

Referenced by IUBroker::immediateWriteCycle().

Here is the call graph for this function:

◆ isAvailable() [1/2]

bool IUResource::isAvailable ( const int cycle ) const

overridevirtual

Test if resource IUResource is available

Parameters

cycle Cycle which to test

Returns: False if all registers in IU are used in cycle

Implements SchedulingResource.

Definition at line 120 of file IUResource.cc.

                                             {
    return isAvailable(cycle, -1);
}

References isAvailable().

Here is the call graph for this function:

◆ isAvailable() [2/2]

bool IUResource::isAvailable	(	const int	cycle,
		int	immRegIndex
	)		const

virtual

Test if resource IUResource is available

Parameters

cycle	Cycle which to test
register	to test. If -1, any reg ok.

Returns: False if all registers in IU are used in cycle

Definition at line 131 of file IUResource.cc.

                                                              {
    int modCycle = instructionIndex(cycle);
    for (int i = 0; i < registerCount(); i++) {
    if (immRegIndex != -1 && i != immRegIndex) continue;
        bool marker = false;
        for (int j = 0 ;
            j < static_cast<int>(resourceRecord_.at(i).size());
            j++) {
            int otherDef = resourceRecord_.at(i).at(j)->definition_;
            int modOtherDef = instructionIndex(otherDef + latency_);
            int otherUse = resourceRecord_.at(i).at(j)->use_;
            int modOtherUse = instructionIndex(otherUse);
 
            // no overlap in old.
            if (modOtherUse >= modOtherDef) {
                // ordinary comparison, use between old def and use?
                if (modCycle > modOtherDef && modCycle < modOtherUse) {
                    marker = true;
                    break;
                }
            } else { 
                // before use before use, or after def of other
                if (modCycle >= modOtherDef || modCycle <= modOtherUse) {
                    marker = true;
                    break;
                }
            }
        }
        // None of the intervals for registers overlapped cycle, register
        // is available for use -> unit is available too
        if (marker == false) {
            return true;
        }
    }
    return false;
}

References SchedulingResource::instructionIndex(), latency_, registerCount(), and resourceRecord_.

Referenced by isAvailable().

Here is the call graph for this function:

◆ isInUse()

bool IUResource::isInUse ( const int cycle ) const

overridevirtual

Test if resource IUResource is used in given cycle

Parameters

cycle Cycle which to test

Returns: True if any (at least one) register of IU is already used in cycle

Implements SchedulingResource.

Definition at line 86 of file IUResource.cc.

                                         {
    int modCycle = instructionIndex(cycle);
    for (int i = 0; i < registerCount(); i++) {
        for (int j = 0;
            j < static_cast<int>(resourceRecord_.at(i).size());
            j++) {
            int otherDef = resourceRecord_.at(i).at(j)->definition_;
            int modOtherDef = instructionIndex(otherDef + latency_);
            int otherUse = resourceRecord_.at(i).at(j)->use_;
            int modOtherUse = instructionIndex(otherUse);
            
            // no overlap in old.
            if (modOtherUse >= modOtherDef) {
                // ordinary comparison, use between old def and use?
                if (modCycle >= modOtherDef && modCycle < modOtherUse) {
                    return true;
                }
            } else { 
                // before use before use, or after def of other
                if (modCycle >= modOtherDef || modCycle <= modOtherUse) {
                    return true;
                }
            }
        }
    }
    return false;
}

References SchedulingResource::instructionIndex(), latency_, registerCount(), and resourceRecord_.

Here is the call graph for this function:

◆ isIUResource()

bool IUResource::isIUResource ( ) const

overridevirtual

Allways return true

Returns: true

Reimplemented from SchedulingResource.

Definition at line 368 of file IUResource.cc.

                               {
    return true;
}

◆ operator=()

IUResource & IUResource::operator= ( const IUResource & )

private

◆ registerCount()

int IUResource::registerCount ( ) const

Get number of registers in IU

Returns: Number of registers in IU

Definition at line 395 of file IUResource.cc.

                                {
    return registerCount_;
}

References registerCount_.

Referenced by clear(), clearOldResources(), findAvailable(), isAvailable(), isInUse(), IUResource(), setRegisterCount(), and ~IUResource().

◆ setRegisterCount()

void IUResource::setRegisterCount ( const int registers )

protected

Set the number of registers available in IU

Parameters

registers Number of registers in this particular IU

Definition at line 377 of file IUResource.cc.

                                                {
    // We shell not provide API for decreasing size of existing IU
    if (registers < registerCount()) {
        throw InvalidData(__FILE__, __LINE__, __func__, 
            "Can not decrease number of registers in IMM unit!");
    }
    for (int i = registerCount_; i < registers; i++) {
        ResourceRecordVectorType vt;
        resourceRecord_.push_back(vt);
    }
    registerCount_ = registers;
}

References __func__, registerCount(), registerCount_, and resourceRecord_.

Here is the call graph for this function:

◆ unassign()

void IUResource::unassign	(	const int	cycle,
		MoveNode &	node
	)

overridevirtual

Unassign resource from given node for given cycle

Parameters

cycle	Cycle in which immediate is read which we want unassign.
node	MoveNode to remove assignment from

Implements SchedulingResource.

Definition at line 240 of file IUResource.cc.

                                              {
 
    if (!node.move().source().isImmediateRegister()) {
        std::string msg = "Trying to unassign move that is not immediate\
            register read!";
        throw KeyNotFound(__FILE__, __LINE__, __func__, msg);
    }
    // Find which register in given IU is assigned to node
    int regIndex = node.move().source().index();
    if (resourceRecord_.at(regIndex).size() == 0) {
        std::string msg = "The register is not assigned!";
        throw KeyNotFound(__FILE__, __LINE__, __func__, msg);
    }
    std::vector<ResourceRecordType*>::iterator itr =
        resourceRecord_.at(regIndex).begin();
    // From given IU register delete record about
    // assignment to node and restore node source
    while (itr != resourceRecord_.at(regIndex).end()) {
        if (node.cycle() == (*itr)->use_) {
            std::shared_ptr<TTAProgram::TerminalImmediate> originalTerminal =
                ((*itr)->immediateValue_);
            if (originalTerminal) {
                TTAProgram::Terminal* toSet = originalTerminal->copy();
                node.move().setSource(toSet);
            }
            delete *itr;
            resourceRecord_.at(regIndex).erase(itr);
            
            return;
        }
        itr++;
    }
    std::string msg = "Register is not assigned for given cycle!";
    throw KeyNotFound(__FILE__, __LINE__, __func__, msg);
}

References __func__, TTAProgram::Terminal::copy(), MoveNode::cycle(), TTAProgram::Terminal::index(), TTAProgram::Terminal::isImmediateRegister(), MoveNode::move(), resourceRecord_, TTAProgram::Move::setSource(), and TTAProgram::Move::source().

Referenced by IUBroker::unassign().

Here is the call graph for this function:

◆ validateDependentGroups()

bool IUResource::validateDependentGroups ( )

overrideprotectedvirtual

Tests if all referred resources in dependent groups are of proper types

Returns: true If all resources in dependent groups are Immediate Registers

Reimplemented from SchedulingResource.

Definition at line 462 of file IUResource.cc.

                                    {
    return true;
}

◆ validateRelatedGroups()

bool IUResource::validateRelatedGroups ( )

overrideprotectedvirtual

Tests if all referred resources in related groups are of proper types

Returns: true If all resources in related groups are Instruction Templates or P-Sockets

Reimplemented from SchedulingResource.

Definition at line 473 of file IUResource.cc.

                                  {
    for (int i = 0; i < relatedResourceGroupCount(); i++) {
        for (int j = 0, count = relatedResourceCount(i); j < count; j++) {
            if (!(relatedResource(i, j).isOutputPSocketResource() ||
                relatedResource(i, j).isInputPSocketResource()   ||
                relatedResource(i, j).isITemplateResource())) {
                return false;
            }
        }
    }
    return true;
}

References SchedulingResource::isInputPSocketResource(), SchedulingResource::isITemplateResource(), SchedulingResource::isOutputPSocketResource(), SchedulingResource::relatedResource(), SchedulingResource::relatedResourceCount(), and SchedulingResource::relatedResourceGroupCount().

Here is the call graph for this function:

◆ width()

int IUResource::width ( ) const

Returns a width of registers in Immediate Unit.

Returns: Width of registers in Immediate Unit.

Definition at line 576 of file IUResource.cc.

                        {
    return width_;
}

References width_.

Referenced by IUBroker::less_width::operator()().

Member Data Documentation

◆ latency_

int IUResource::latency_

private

Definition at line 129 of file IUResource.hh.

Referenced by assign(), canAssign(), findAvailable(), isAvailable(), and isInUse().

◆ machine_

const TTAMachine::Machine& IUResource::machine_

private

Definition at line 133 of file IUResource.hh.

Referenced by canAssign().

◆ registerCount_

int IUResource::registerCount_

private

Definition at line 125 of file IUResource.hh.

Referenced by registerCount(), and setRegisterCount().

◆ resourceRecord_

std::vector<ResourceRecordVectorType> IUResource::resourceRecord_

private

Definition at line 123 of file IUResource.hh.

Referenced by assign(), assign(), clear(), clearOldResources(), findAvailable(), immediateValue(), immediateWriteCycle(), isAvailable(), isInUse(), IUResource(), setRegisterCount(), unassign(), and ~IUResource().

◆ signExtension_

bool IUResource::signExtension_

private

Definition at line 131 of file IUResource.hh.

Referenced by canAssign().

◆ width_

int IUResource::width_

private

Definition at line 127 of file IUResource.hh.

Referenced by canAssign(), and width().

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

Classes

Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ ResourceRecordVectorType

Constructor & Destructor Documentation

◆ ~IUResource()

◆ IUResource() [1/2]

◆ IUResource() [2/2]

Member Function Documentation

◆ assign() [1/2]

◆ assign() [2/2]

◆ canAssign() [1/2]

◆ canAssign() [2/2]

◆ canAssignUse()

◆ clear()

◆ clearOldResources()

◆ findAvailable()

◆ immediateValue()

◆ immediateWriteCycle()

◆ isAvailable() [1/2]

◆ isAvailable() [2/2]

◆ isInUse()

◆ isIUResource()

◆ operator=()

◆ registerCount()

◆ setRegisterCount()

◆ unassign()

◆ validateDependentGroups()

◆ validateRelatedGroups()

◆ width()

Member Data Documentation

◆ latency_

◆ machine_

◆ registerCount_

◆ resourceRecord_

◆ signExtension_

◆ width_