BusBroker Class Reference

#include <BusBroker.hh>

Inheritance diagram for BusBroker:

Collaboration diagram for BusBroker:

Public Member Functions
	BusBroker (std::string name, ResourceBroker &ipBroker, ResourceBroker &opBroker, const TTAMachine::Machine &mach, unsigned int initiationInterval=0)
virtual	~BusBroker ()
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 override
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 override
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 override
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 override
virtual void	assign (int cycle, MoveNode &node, SchedulingResource &res, int immWriteCycle, int immRegIndex) override
virtual void	unassign (MoveNode &node)
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)
virtual void	setupResourceLinks (const ResourceMapper &mapper)
virtual bool	isBusBroker () const
virtual bool	canTransportImmediate (const MoveNode &node, const TTAMachine::Bus *preAssigndBus) const
virtual bool	isInUse (int cycle, const MoveNode &node) const
virtual bool	hasGuard (const MoveNode &node) const
void	clear () override
void	setCFG (const ControlFlowGraph *cfg)
void	setBBN (const BasicBlockNode *bbn)
Public Member Functions inherited from ResourceBroker
	ResourceBroker (std::string, unsigned int initiationInterval=0)
virtual	~ResourceBroker ()
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	isITemplateBroker () 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 Member Functions
bool	jumpToBBN (const MoveNode &mn, BasicBlockNode &bbn) const
bool	canPerformSIMMJump (const MoveNode &mn, ShortImmPSocketResource &immRes) const
virtual bool	canTransportImmediate (const MoveNode &node, ShortImmPSocketResource &immRes) const
virtual ShortImmPSocketResource &	findImmResource (BusResource &busRes) const

Private Attributes
std::list< SchedulingResource * >	shortImmPSocketResources_
std::map< const MoveNode *, bool >	busPreassigned_
ResourceBroker &	inputPSocketBroker_
ResourceBroker &	outputPSocketBroker_
bool	hasLimm_
const TTAMachine::Machine *	mach_
const ControlFlowGraph *	cfg_
const BasicBlockNode *	bbn_

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

Bus broker.

Definition at line 60 of file BusBroker.hh.

Constructor & Destructor Documentation

BusBroker()

BusBroker::BusBroker	(	std::string	name,
		ResourceBroker &	ipBroker,
		ResourceBroker &	opBroker,
		const TTAMachine::Machine &	mach,
		unsigned int	initiationInterval = 0
	)

Constructor.

Parameters

name	name for this broker.
ipsb	reference to InputPSocketBroker of this RM.
opsb	reference to OutputPSocketBroker of this RM.
initiationInterval	initiationinterval when doing loop scheduling.

Definition at line 73 of file BusBroker.cc.

                                     :
    ResourceBroker(name, initiationInterval), inputPSocketBroker_(ipBroker),
    outputPSocketBroker_(opBroker), hasLimm_(false), mach_(&mach) {
}

~BusBroker()

BusBroker::~BusBroker ( )

virtual

Destructor.

Definition at line 86 of file BusBroker.cc.

                     {
    SequenceTools::deleteAllItems(shortImmPSocketResources_);
}

References SequenceTools::deleteAllItems(), and shortImmPSocketResources_.

Here is the call graph for this function:

Member Function Documentation

allAvailableResources()

SchedulingResourceSet BusBroker::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

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.
bus	if not null, bus that has to be used.
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

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

Reimplemented from ResourceBroker.

Definition at line 178 of file BusBroker.cc.

                                               {
 
    cycle = instructionIndex(cycle);
    SchedulingResourceSet candidates;
 
    Move& move = const_cast<MoveNode&>(node).move();
    const Port* dstPort = &move.destination().port();
    Socket* inputSocket = dstPort->inputSocket();
 
    // In case bus was already assigned previously, pick only relevant resource.
    UniversalMachine& um = UniversalMachine::instance();
    BusResource* preassignedBus = NULL;
    if (&move.bus() != &um.universalBus()) {
        preassignedBus = dynamic_cast<BusResource*>(resourceOf(move.bus()));
    }
    if (bus != NULL) {
        preassignedBus = dynamic_cast<BusResource*>(resourceOf(*bus));
    }
 
    if (inputSocket == NULL) {
        string unit = dstPort->parentUnit()->name();
        string port = dstPort->name();
        string msg =
            "Tried to find bus for a move to '" + unit + "." + port +
            "' which has no connections to an input socket. "
            "Check operation bindings!";
        throw ModuleRunTimeError(__FILE__, __LINE__, __func__, msg);
    }
 
    InputPSocketResource* iPSocket = NULL;
    try {
        iPSocket = 
            static_cast<InputPSocketResource*>(
                inputPSocketBroker_.resourceOf(*inputSocket));
    } catch (const KeyNotFound& e) {
        std::string msg = "BusBroker: finding ";
        msg += " resource for Socket ";
        msg += " failed with error: ";
        msg += e.errorMessageStack();
        throw KeyNotFound(
            __FILE__, __LINE__, __func__, msg);
    }                                                            
 
    OutputPSocketResource* oPSocket = NULL;
 
    if (move.source().isImmediate()) {
 
        // find a bus with appropriate immediate width that is connected to
        // destination
        ResourceMap::const_iterator resIter = resMap_.begin();
        while (resIter != resMap_.end()) {
            // look for bus resources with appropriate related shortimmsocket
            // resources
            BusResource* busRes =
                static_cast<BusResource*>((*resIter).second);
            if (busRes == NULL) {
                throw InvalidData(
                    __FILE__, __LINE__, __func__,
                    "Bus broker has other then Bus Resource registered!");
            }
 
            ShortImmPSocketResource& immRes = findImmResource(*busRes);
            if (preassignedBus == NULL || busRes == preassignedBus) {
                if (canTransportImmediate(node, immRes) &&
                    busRes->canAssign(cycle, node, immRes, *iPSocket)) {
                    candidates.insert(*busRes);
                }
            }
            resIter++;
        }
 
    } else {
 
        const Port* srcPort = &move.source().port();
        Socket* outputSocket = srcPort->outputSocket();
        if (outputSocket == NULL) {
            string unit = srcPort->parentUnit()->name();
            string port = srcPort->name();
            string msg =
                "Tried to find bus for a move from '" + unit + "." + port +
                "' which has no connections to an output socket! Check "
                "operation bindings!";
            throw ModuleRunTimeError(__FILE__, __LINE__, __func__, msg);
        }
 
        oPSocket = NULL;
        try {
            oPSocket = 
            static_cast<OutputPSocketResource*>(
                outputPSocketBroker_.resourceOf(*outputSocket));
        } catch (const KeyNotFound& e) {
            std::string msg = "BusBroker: finding ";
            msg += " resource for Socket ";
            msg += " failed with error: ";
            msg += e.errorMessageStack();
            throw KeyNotFound(
                __FILE__, __LINE__, __func__, msg);
        }                                                            
 
        ResourceMap::const_iterator resIter = resMap_.begin();
        while (resIter != resMap_.end()) {
            BusResource* busRes =
                static_cast<BusResource*>((*resIter).second);
            if (preassignedBus == NULL ||
                busRes == preassignedBus) {
                if (busRes->canAssign(cycle, node, *oPSocket, *iPSocket)) {
                    candidates.insert(*busRes);
                }
            }
            resIter++;
        }
    }
    if (!move.isUnconditional()) {
 
        const Guard& guard = move.guard().guard();
        for (int i = 0; i < candidates.count(); i++) {
            SchedulingResource& busResource = candidates.resource(i);
            const Bus* aBus =
                static_cast<const Bus*>(&machinePartOf(busResource));
            if (aBus == NULL) {
                throw InvalidData(
                    __FILE__, __LINE__, __func__,
                    "Bus Resource is missing bus in MOM!");
            }
 
            bool guardFound = false;
            for (int j = 0; j < aBus->guardCount(); j++) {
                Guard* busGuard = aBus->guard(j);
                if (busGuard->isEqual(guard)) {
                    guardFound = true;
                    break;
                }
            }
 
            if (!guardFound) {
                candidates.remove(busResource);
                i--;
            }
        }
    }
    return candidates;
}

References __func__, TTAProgram::Move::bus(), BusResource::canAssign(), canTransportImmediate(), SchedulingResourceSet::count(), TTAProgram::Move::destination(), Exception::errorMessageStack(), findImmResource(), TTAProgram::MoveGuard::guard(), TTAProgram::Move::guard(), TTAMachine::Bus::guard(), TTAMachine::Bus::guardCount(), inputPSocketBroker_, TTAMachine::Port::inputSocket(), SchedulingResourceSet::insert(), UniversalMachine::instance(), ResourceBroker::instructionIndex(), TTAMachine::Guard::isEqual(), TTAProgram::Terminal::isImmediate(), TTAProgram::Move::isUnconditional(), ResourceBroker::machinePartOf(), TTAMachine::Port::name(), TTAMachine::Component::name(), outputPSocketBroker_, TTAMachine::Port::outputSocket(), TTAMachine::Port::parentUnit(), TTAProgram::Terminal::port(), SchedulingResourceSet::remove(), ResourceBroker::resMap_, SchedulingResourceSet::resource(), ResourceBroker::resourceOf(), TTAProgram::Move::source(), and UniversalMachine::universalBus().

Referenced by availableResource(), and isAnyResourceAvailable().

Here is the call graph for this function:

assign()

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

Parameters

cycle	Cycle for which to assign bus
node	Node which will be transfered using a bus
res	ResourceObject referring to particular bus to assign

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.

Implements ResourceBroker.

Definition at line 474 of file BusBroker.cc.

                                                                  {
 
    cycle = instructionIndex(cycle);
    BusResource& busRes = static_cast<BusResource&>(res);
    Move& move = const_cast<MoveNode&>(node).move();
    if (hasResource(res)) {
        Bus& bus =
            const_cast<Bus&>(static_cast<const Bus&>(machinePartOf(res)));
 
        UniversalMachine& um = UniversalMachine::instance();
        if (&move.bus() != &um.universalBus()) {
            busPreassigned_[&node] = true;
            assert(&bus == &move.bus() &&
                   "preassigned bus which is different than selected bus?");
        } else {
            move.setBus(bus);
            busPreassigned_[&node] = false;
        }
        if (!move.isUnconditional()) {
            for (int j = 0; j < bus.guardCount(); j++) {
                Guard* busGuard = bus.guard(j);
                if (busGuard->isEqual(move.guard().guard())) {
                    move.setGuard(new MoveGuard(*busGuard));
                    break;
                }
            }
        }
        busRes.assign(cycle,node);
    } else {
        string msg = "Broker does not contain given resource.";
        throw InvalidData(__FILE__, __LINE__, __func__, msg);
    }
    assignedResources_.insert(
        std::pair<const MoveNode*, SchedulingResource*>(&node, &busRes));
}

References __func__, assert, BusResource::assign(), ResourceBroker::assignedResources_, TTAProgram::Move::bus(), busPreassigned_, TTAProgram::MoveGuard::guard(), TTAProgram::Move::guard(), TTAMachine::Bus::guard(), TTAMachine::Bus::guardCount(), ResourceBroker::hasResource(), UniversalMachine::instance(), ResourceBroker::instructionIndex(), TTAMachine::Guard::isEqual(), TTAProgram::Move::isUnconditional(), ResourceBroker::machinePartOf(), TTAProgram::Move::setBus(), TTAProgram::Move::setGuard(), and UniversalMachine::universalBus().

Here is the call graph for this function:

availableResource()

SchedulingResource & BusBroker::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

overridevirtual

Return one (any) resource managed by this broker that can be assigned to the given node in the given cycle.

If no change occurs to the state of the resources, the broker should always return the same object. If a resource of the type managed by this broker is already assigned to the node, it is returned.

Parameters

cycle	Cycle.
node	Node.
bus	if not null, bus that has to be used.
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

One (any) resource managed by this broker that can be assigned to the given node in the given cycle.

Exceptions

InstanceNotFound

If no available resource is found.

Reimplemented from ResourceBroker.

Definition at line 141 of file BusBroker.cc.

                                                    {
 
    cycle = instructionIndex(cycle);
    SchedulingResourceSet allAvailableBuses =
        allAvailableResources(cycle, node, bus, srcFU, dstFU, immWriteCycle,
                  immu, immRegIndex);
    if (allAvailableBuses.count() == 0) {
        string msg = "No available resource found.";
        throw InstanceNotFound(__FILE__, __LINE__, __func__, msg);
    } else {
        if (bus != NULL) {
            assert(allAvailableBuses.count() == 1);
        }
        return allAvailableBuses.resource(0);
    }
}

References __func__, allAvailableResources(), assert, SchedulingResourceSet::count(), ResourceBroker::instructionIndex(), and SchedulingResourceSet::resource().

Here is the call graph for this function:

buildResources()

void BusBroker::buildResources ( const TTAMachine::Machine &  target )

virtual

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 646 of file BusBroker.cc.

                                                         {
    hasLimm_ = target.immediateUnitNavigator().count() > 0;
    Machine::BusNavigator navi = target.busNavigator();
    Machine::InstructionTemplateNavigator itn = 
        target.instructionTemplateNavigator();
 
    std::map<const Bus*,int> limmSlotCounts;
    std::map<const Bus*,int> nopSlotCounts;
    
    // calculate count of limm slots and nop slots associated with each bus.
    // used to priorize busses which do not get into way of limm writes.
    for (int i = 0; i < itn.count(); i++) {
        InstructionTemplate* it = itn.item(i);
        for (int j = 0; j < it->slotCount(); j++) {
            TemplateSlot* itSlot = it->slot(j);
            if (itSlot->destination() != NULL) {
                limmSlotCounts[itSlot->bus()]++; 
            }
        }
    }
 
    for (int i = 0; i < navi.count(); i++) {
        Bus* bus = navi.item(i);
        assert(bus->segmentCount() == 1);
        int socketCount = bus->segment(0)->connectionCount();
        BusResource* busResource = new BusResource(
            bus->name(), bus->width(),limmSlotCounts[bus],
            nopSlotCounts[bus], bus->guardCount(),
            bus->immediateWidth(), socketCount, initiationInterval_);
        ResourceBroker::addResource(*bus, busResource);
    }
}

References ResourceBroker::addResource(), assert, TTAMachine::TemplateSlot::bus(), TTAMachine::Machine::busNavigator(), TTAMachine::Segment::connectionCount(), TTAMachine::Machine::Navigator< ComponentType >::count(), TTAMachine::TemplateSlot::destination(), hasLimm_, TTAMachine::Machine::immediateUnitNavigator(), ResourceBroker::initiationInterval_, TTAMachine::Machine::instructionTemplateNavigator(), TTAMachine::Machine::Navigator< ComponentType >::item(), TTAMachine::Component::name(), TTAMachine::Bus::segment(), TTAMachine::Bus::segmentCount(), TTAMachine::InstructionTemplate::slot(), TTAMachine::InstructionTemplate::slotCount(), and TTAMachine::Bus::width().

Here is the call graph for this function:

canPerformSIMMJump()

bool BusBroker::canPerformSIMMJump ( const MoveNode &  mn, ShortImmPSocketResource &  immRes  ) const

private

Definition at line 801 of file BusBroker.cc.

                                                     {
    return false; // WiP.
}

Referenced by canTransportImmediate().

canTransportImmediate() [1/2]

bool BusBroker::canTransportImmediate ( const MoveNode &  node, const TTAMachine::Bus *  preassignedBus  ) const

virtual

Return true if immediate in given node can be transported by any bus in broker, with the guard which the move contains.

Parameters

node	Node that contains immediate read.

Returns

True if immediate in given node can be transported by any bus in broker.

Definition at line 756 of file BusBroker.cc.

                                                                     {
    ResourceMap::const_iterator resIter = resMap_.begin();
    while (resIter != resMap_.end()) {
        BusResource* busRes = static_cast<BusResource*>((*resIter).second);
        ShortImmPSocketResource* immRes = &findImmResource(*busRes);
        const Bus* aBus = static_cast<const Bus*>(resIter->first);
        if (preassignedBus != NULL && aBus != preassignedBus) {
            resIter++;
            continue;
        }
        if (canTransportImmediate(node, *immRes)) {
            bool guardOK = false;
            if (node.move().isUnconditional()) {
                guardOK = true;
            } else {
                // We need to check that the bus contains the guard
                // which the move has. Only return true if the
                // guard is found from the bus.
                const Guard& guard = node.move().guard().guard();
                for (int j = 0; j < aBus->guardCount(); j++) {
                    Guard* busGuard = aBus->guard(j);
                    if (busGuard->isEqual(guard)) {
                        guardOK = true;
                        break;
                    }
                }
            }
            if (guardOK) {
                if (!hasLimm_) {
                    return true;
                } else {
                    if (MachineConnectivityCheck::busConnectedToDestination(
                            *aBus, node)) {
                        return true;
                    }
                }
            }
        }
        resIter++;
    }
    return false;
}

References MachineConnectivityCheck::busConnectedToDestination(), findImmResource(), TTAProgram::MoveGuard::guard(), TTAProgram::Move::guard(), TTAMachine::Bus::guard(), TTAMachine::Bus::guardCount(), hasLimm_, TTAMachine::Guard::isEqual(), TTAProgram::Move::isUnconditional(), MoveNode::move(), and ResourceBroker::resMap_.

Referenced by allAvailableResources(), SimpleBrokerDirector::canTransportImmediate(), and isAvailable().

Here is the call graph for this function:

canTransportImmediate() [2/2]

bool BusBroker::canTransportImmediate ( const MoveNode &  node, ShortImmPSocketResource &  immRes  ) const

privatevirtual

Return true if immediate in given node can be transported by bus that is represented by given p-socket resource.

Parameters

node	Node that contains immediate read.
immRes	P-socket resource representing write if immediate to related bus.

Returns

True if immediate in given node can be transported by bus that is represented by given p-socket resource.

Definition at line 817 of file BusBroker.cc.

                                           {
 
    Move& move = const_cast<MoveNode&>(node).move();
 
    if (move.isJump() && canPerformSIMMJump(node, immRes)) {
        return true;
    }
 
    int bits = MachineConnectivityCheck::requiredImmediateWidth(
        immRes.signExtends(),
        static_cast<const TTAProgram::TerminalImmediate&>(move.source()),
        *mach_);
 
    if (bits <= immRes.immediateWidth()) {
        return true;
    } else {
        return false;
    }
}

References canPerformSIMMJump(), ShortImmPSocketResource::immediateWidth(), TTAProgram::Move::isJump(), mach_, MachineConnectivityCheck::requiredImmediateWidth(), ShortImmPSocketResource::signExtends(), and TTAProgram::Move::source().

Here is the call graph for this function:

clear()

void BusBroker::clear ( )

overridevirtual

Clears all resources managed by the broker so that the broker can be reused.

Reimplemented from ResourceBroker.

Definition at line 889 of file BusBroker.cc.

                 {
    ResourceBroker::clear();
    for (std::list<SchedulingResource*>::iterator i = 
             shortImmPSocketResources_.begin(); 
         i != shortImmPSocketResources_.end(); i++) {
        (*i)->clear();
    }
    busPreassigned_.clear();
}

References busPreassigned_, ResourceBroker::clear(), and shortImmPSocketResources_.

Here is the call graph for this function:

earliestCycle()

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

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 550 of file BusBroker.cc.

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

References abortWithError.

findImmResource()

ShortImmPSocketResource & BusBroker::findImmResource ( BusResource &  busRes ) const

privatevirtual

Return the short immediate p-socket resource related to given bus.

Parameters

busRes

Bus resource.

Returns

The short immediate p-socket resource related to given bus.

Definition at line 846 of file BusBroker.cc.

                                                    {
    int i = 0;
    SchedulingResource* socketRes = NULL;
    ShortImmPSocketResource* immRes = NULL;
    while (i < busRes.relatedResourceCount(0)) {
        socketRes = &busRes.relatedResource(0, i);
        if (socketRes->isShortImmPSocketResource()) {
            return *(static_cast<ShortImmPSocketResource*>(socketRes));
        }
        i++;
    }
    return *immRes;
}

References SchedulingResource::isShortImmPSocketResource(), SchedulingResource::relatedResource(), and SchedulingResource::relatedResourceCount().

Referenced by allAvailableResources(), canTransportImmediate(), and isAvailable().

Here is the call graph for this function:

hasGuard()

bool BusBroker::hasGuard ( const MoveNode &  node ) const

virtual

Tests if any of a buses known to BusBroker supports a guard required by MoveNode.

Parameters

node	MoveNode to test.

Returns

true if some of the buses supports guard of node.

Definition at line 868 of file BusBroker.cc.

                                              {
    Move& move = const_cast<MoveNode&>(node).move();
    const Guard& guard = move.guard().guard();
    ResourceMap::const_iterator resIter = resMap_.begin();
    while (resIter != resMap_.end()) {
        SchedulingResource& busResource = *(*resIter).second;
        const Bus* aBus =
            static_cast<const Bus*>(&machinePartOf(busResource));
 
        for (int j = 0; j < aBus->guardCount(); j++) {
            Guard* busGuard = aBus->guard(j);
            if (busGuard->isEqual(guard)) {
                return true;
            }
        }
        resIter++;
    }
    return false;
}

References TTAProgram::MoveGuard::guard(), TTAProgram::Move::guard(), TTAMachine::Bus::guard(), TTAMachine::Bus::guardCount(), TTAMachine::Guard::isEqual(), ResourceBroker::machinePartOf(), and ResourceBroker::resMap_.

Referenced by SimpleBrokerDirector::hasGuard().

Here is the call graph for this function:

isAlreadyAssigned()

bool BusBroker::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 594 of file BusBroker.cc.

                                                                 {
    if (!MapTools::containsKey(assignedResources_, &node)) {
        return false;
    }
    return isInUse(instructionIndex(cycle),node);
}

References ResourceBroker::assignedResources_, MapTools::containsKey(), ResourceBroker::instructionIndex(), and isInUse().

Here is the call graph for this function:

isAnyResourceAvailable()

bool BusBroker::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 one of the resources managed by this broker is suitable for the request contained in the node and can be assigned to it in given cycle.

Parameters

cycle	Cycle.
node	Node.
bus	if not null, bus that has to be used.
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

True if one of the resources managed by this broker is suitable for the request contained in the node and can be assigned to it in given cycle.

Reimplemented from ResourceBroker.

Definition at line 106 of file BusBroker.cc.

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

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

Here is the call graph for this function:

isApplicable()

bool BusBroker::isApplicable ( const MoveNode &  mn, 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.

Implements ResourceBroker.

Definition at line 632 of file BusBroker.cc.

                                                                      {
    return mn.isMove();
}

References MoveNode::isMove().

Here is the call graph for this function:

isAvailable()

bool BusBroker::isAvailable ( SchedulingResource &  res, 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

overridevirtual

Tells whether the given resource is available for given node at given cycle.

Reimplemented from ResourceBroker.

Definition at line 332 of file BusBroker.cc.

                                               {
 
    if  (bus != NULL && resourceOf(*bus) != &res) {
        return false;
    }
    cycle = instructionIndex(cycle);
 
    Move& move = const_cast<MoveNode&>(node).move();
    const Port* dstPort = &move.destination().port();
    Socket* inputSocket = dstPort->inputSocket();
 
    if (inputSocket == NULL) {
        string unit = dstPort->parentUnit()->name();
        string port = dstPort->name();
        string msg =
            "Tried to find bus for a move to '" + unit + "." + port +
            "' which has no connections to an input socket. "
            "Check operation bindings!";
        throw ModuleRunTimeError(__FILE__, __LINE__, __func__, msg);
    }
 
    InputPSocketResource* iPSocket = NULL;
    try {
        iPSocket = 
            static_cast<InputPSocketResource*>(
                inputPSocketBroker_.resourceOf(*inputSocket));
    } catch (const KeyNotFound& e) {
        std::string msg = "BusBroker: finding ";
        msg += " resource for Socket ";
        msg += " failed with error: ";
        msg += e.errorMessageStack();
        throw KeyNotFound(
            __FILE__, __LINE__, __func__, msg);
    }                                                            
 
    OutputPSocketResource* oPSocket = NULL;
 
    if (move.source().isImmediate()) {
        
        // look for bus resources with appropriate related shortimmsocket
        // resources
        BusResource* busRes =
            dynamic_cast<BusResource*>(&res);
        if (busRes == NULL) {
            throw InvalidData(
                __FILE__, __LINE__, __func__,
                "Wrong type of resource for the broker given!");
        }
        
        ShortImmPSocketResource& immRes = findImmResource(*busRes);
        if (!canTransportImmediate(node, immRes) &&
            busRes->canAssign(cycle, node, immRes, *iPSocket)) {
            return false;
        }
    } else {
        const Port* srcPort = &move.source().port();
        Socket* outputSocket = srcPort->outputSocket();
        if (outputSocket == NULL) {
            string unit = srcPort->parentUnit()->name();
            string port = srcPort->name();
            string msg =
                "Tried to find bus for a move from '" + unit + "." + port +
                "' which has no connections to an output socket! Check "
                "operation bindings!";
            throw ModuleRunTimeError(__FILE__, __LINE__, __func__, msg);
        }
 
        oPSocket = NULL;
        try {
            oPSocket = 
            static_cast<OutputPSocketResource*>(
                outputPSocketBroker_.resourceOf(*outputSocket));
        } catch (const KeyNotFound& e) {
            std::string msg = "BusBroker: finding ";
            msg += " resource for Socket ";
            msg += " failed with error: ";
            msg += e.errorMessageStack();
            throw KeyNotFound(
                __FILE__, __LINE__, __func__, msg);
        }                                                            
 
        BusResource* busRes =
            dynamic_cast<BusResource*>(&res);
        if (busRes == NULL) {
            throw InvalidData(
                __FILE__, __LINE__, __func__,
                "Wrong type of resource for the broker given!");
        }
        
        if (!busRes->canAssign(cycle, node, *oPSocket, *iPSocket)) {
            return false;
        }
    }
    if (!move.isUnconditional()) {
 
        const Guard& guard = move.guard().guard();
        const Bus* aBus =
            dynamic_cast<const Bus*>(&machinePartOf(res));
        if (aBus == NULL) {
            throw InvalidData(
                __FILE__, __LINE__, __func__,
                "Bus Resource is missing bus in MOM!");
        }
        
        bool guardFound = false;
        for (int j = 0; j < aBus->guardCount(); j++) {
            Guard* busGuard = aBus->guard(j);
            if (busGuard->isEqual(guard)) {
                guardFound = true;
                break;
            }
        }
        
        if (!guardFound) {
            return false;
        }
    }
    return true;
}

References __func__, BusResource::canAssign(), canTransportImmediate(), TTAProgram::Move::destination(), Exception::errorMessageStack(), findImmResource(), TTAProgram::MoveGuard::guard(), TTAProgram::Move::guard(), TTAMachine::Bus::guard(), TTAMachine::Bus::guardCount(), inputPSocketBroker_, TTAMachine::Port::inputSocket(), ResourceBroker::instructionIndex(), TTAMachine::Guard::isEqual(), TTAProgram::Terminal::isImmediate(), TTAProgram::Move::isUnconditional(), ResourceBroker::machinePartOf(), TTAMachine::Port::name(), TTAMachine::Component::name(), outputPSocketBroker_, TTAMachine::Port::outputSocket(), TTAMachine::Port::parentUnit(), TTAProgram::Terminal::port(), ResourceBroker::resourceOf(), and TTAProgram::Move::source().

Here is the call graph for this function:

isBusBroker()

bool BusBroker::isBusBroker ( ) const

virtual

Return true always.

Returns

True always.

Reimplemented from ResourceBroker.

Definition at line 743 of file BusBroker.cc.

                             {
    return true;
}

isInUse()

bool BusBroker::isInUse ( int  cycle, const MoveNode &  node  ) const

virtual

Return true if given node already uses a resource of the type managed by this broker and assignment appears to be valid.

Parameters

cycle	Cycle to test
node	Node to test

Returns

True if given node already uses a resource of the type managed by the broker.

Definition at line 612 of file BusBroker.cc.

                                                        {
    cycle = instructionIndex(cycle);
    const Bus& bus = const_cast<MoveNode&>(node).move().bus();
    if (!hasResourceOf(bus)) {
        return false;
    }
 
    SchedulingResource* res = resourceOf(bus);
    BusResource& busRes = static_cast<BusResource&>(*res);
    return busRes.isInUse(cycle);
}

References ResourceBroker::hasResourceOf(), ResourceBroker::instructionIndex(), BusResource::isInUse(), and ResourceBroker::resourceOf().

Referenced by isAlreadyAssigned().

Here is the call graph for this function:

jumpToBBN()

bool BusBroker::jumpToBBN ( const MoveNode &  mn, BasicBlockNode &  bbn  ) const

private

latestCycle()

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

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 571 of file BusBroker.cc.

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

References abortWithError.

setBBN()

void BusBroker::setBBN ( const BasicBlockNode *  bbn )

inline

Definition at line 136 of file BusBroker.hh.

{ bbn_ = bbn; }

References bbn_.

Referenced by SimpleBrokerDirector::setBBN().

setCFG()

void BusBroker::setCFG ( const ControlFlowGraph *  cfg )

inline

Definition at line 135 of file BusBroker.hh.

{ cfg_ = cfg; }

References cfg_.

Referenced by SimpleBrokerDirector::setCFG().

setupResourceLinks()

void BusBroker::setupResourceLinks ( const ResourceMapper &  mapper )

virtual

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 688 of file BusBroker.cc.

                                                          {
 
    setResourceMapper(mapper);
 
    for (ResourceMap::iterator resIter = resMap_.begin();
         resIter != resMap_.end(); resIter++) {
 
        const Bus* bus = dynamic_cast<const Bus*>((*resIter).first);
        if (bus == NULL) {
            throw InvalidData(
                __FILE__, __LINE__, __func__,
                "Bus broker has other then Bus Resource registered!");
        }        
 
        SchedulingResource* busResource = (*resIter).second;
 
        int immWidth = bus->immediateWidth();
 
        ShortImmPSocketResource* immSocketResource =
            new ShortImmPSocketResource(
                bus->name() + "Imm", immWidth, bus->signExtends(),
                initiationInterval_);
 
        shortImmPSocketResources_.push_back(immSocketResource);
        busResource->addToRelatedGroup(0, *immSocketResource);
 
        for (int i = 0; i < bus->segmentCount(); i++) {
            Segment* seg = bus->segment(i);
            for (int j = 0; j < seg->connectionCount(); j++) {
                Socket* socket = seg->connection(j);
                SchedulingResource* relRes = 
                    inputPSocketBroker_.resourceOf(*socket);
                if (relRes == NULL) {
                    relRes = outputPSocketBroker_.resourceOf(*socket);
                }
                if (relRes != NULL) {
                    busResource->addToRelatedGroup(0, *relRes);
                } else {
                    std::string msg = "BusBroker: finding ";
                    msg += " resource for Socket ";
                    msg += " failed. ";
                    throw KeyNotFound(
                        __FILE__, __LINE__, __func__, msg);
                }
            }
        }
    }
}

References __func__, SchedulingResource::addToRelatedGroup(), TTAMachine::Segment::connection(), TTAMachine::Segment::connectionCount(), TTAMachine::Bus::immediateWidth(), ResourceBroker::initiationInterval_, inputPSocketBroker_, TTAMachine::Component::name(), outputPSocketBroker_, ResourceBroker::resMap_, ResourceBroker::resourceOf(), TTAMachine::Bus::segment(), TTAMachine::Bus::segmentCount(), ResourceBroker::setResourceMapper(), shortImmPSocketResources_, and TTAMachine::Bus::signExtends().

Here is the call graph for this function:

unassign()

void BusBroker::unassign ( MoveNode &  node )

virtual

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 to unassign.

Implements ResourceBroker.

Definition at line 522 of file BusBroker.cc.

                                  {
 
    if (MapTools::containsKey(assignedResources_, &node)) {
        Move& move = const_cast<MoveNode&>(node).move();
        const Bus& bus = move.bus();
        SchedulingResource* res = resourceOf(bus);
        BusResource& busRes = static_cast<BusResource&>(*res);
        busRes.unassign(node.cycle(),node);
        assignedResources_.erase(&node);
        if (!busPreassigned_[&node]) {
            UniversalMachine& um = UniversalMachine::instance();
            move.setBus(um.universalBus());
        }
    }
}

References ResourceBroker::assignedResources_, TTAProgram::Move::bus(), busPreassigned_, MapTools::containsKey(), MoveNode::cycle(), UniversalMachine::instance(), ResourceBroker::resourceOf(), TTAProgram::Move::setBus(), BusResource::unassign(), and UniversalMachine::universalBus().

Here is the call graph for this function:

Member Data Documentation

bbn_

const BasicBlockNode* BusBroker::bbn_

private

Definition at line 153 of file BusBroker.hh.

Referenced by setBBN().

busPreassigned_

std::map<const MoveNode*, bool> BusBroker::busPreassigned_

private

Definition at line 147 of file BusBroker.hh.

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

cfg_

const ControlFlowGraph* BusBroker::cfg_

private

Definition at line 152 of file BusBroker.hh.

Referenced by setCFG().

hasLimm_

bool BusBroker::hasLimm_

private

Definition at line 150 of file BusBroker.hh.

Referenced by buildResources(), and canTransportImmediate().

inputPSocketBroker_

ResourceBroker& BusBroker::inputPSocketBroker_

private

Definition at line 148 of file BusBroker.hh.

Referenced by allAvailableResources(), isAvailable(), and setupResourceLinks().

mach_

const TTAMachine::Machine* BusBroker::mach_

private

Definition at line 151 of file BusBroker.hh.

Referenced by canTransportImmediate().

outputPSocketBroker_

ResourceBroker& BusBroker::outputPSocketBroker_

private

Definition at line 149 of file BusBroker.hh.

Referenced by allAvailableResources(), isAvailable(), and setupResourceLinks().

shortImmPSocketResources_

std::list<SchedulingResource*> BusBroker::shortImmPSocketResources_

private

Definition at line 146 of file BusBroker.hh.

Referenced by clear(), setupResourceLinks(), and ~BusBroker().

---

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

• BusBroker.hh
• BusBroker.cc