ADFCombiner Class Reference

Inheritance diagram for ADFCombiner:

Collaboration diagram for ADFCombiner:

Private Types
typedef std::vector< TTAMachine::Bus * >	BusVector
typedef std::set< TTAMachine::Guard *, TTAMachine::MachinePart::Comparator >	GuardSet

Private Member Functions
	PLUGIN_DESCRIPTION ("Explorer plugin that produces a clustered machine with N lanes/nodes " "and an 'extras' node.")
	ADFCombiner ()
virtual bool	requiresStartingPointArchitecture () const
virtual bool	producesArchitecture () const
virtual bool	requiresHDB () const
virtual bool	requiresSimulationData () const
virtual bool	requiresApplication () const
virtual std::vector< RowID >	explore (const RowID &, const unsigned int &)
void	readParameters ()
GuardSet	findGuards (TTAMachine::Machine *mach)
void	addComponents (TTAMachine::Machine *finalMach, TTAMachine::Machine *nodeMach, TTAMachine::Machine *extraMach, unsigned nodeCount)
TCEString	nodeNamePrefix (int nodeId)
void	addAllGuardsToConnectionBuses (TTAMachine::Machine *finalMach, const BusVector &connectionBuses)
void	addGuardsToBuses (std::map< Bus *, std::pair< Bus *, int > > &busMapping, GuardSet &extrasGuards)
void	addBuses (TTAMachine::Machine *finalMach, TTAMachine::Machine *nodeMach, unsigned nodeCount, std::map< Bus *, std::pair< Bus *, int > > &busMapping)
void	addRegisterFiles (TTAMachine::Machine *finalMach, TTAMachine::Machine *nodeMach, unsigned nodeCount)
void	addFunctionUnits (TTAMachine::Machine *finalMach, TTAMachine::Machine *nodeMach, unsigned nodeCount)
void	connectPorts (TTAMachine::Machine *finalMach, TTAMachine::Unit *original, TTAMachine::Unit *newUnit, int count)
void	addAddressSpaces (TTAMachine::Machine *finalMach, TTAMachine::Machine *nodeMach)
void	connectRegisterFiles (TTAMachine::Machine *finalMach, TTAMachine::Machine *nodeMach, TTAMachine::Machine *extraMach, unsigned nodeCount, std::set< TTAMachine::Guard *, TTAMachine::MachinePart::Comparator > extrasGuards, BusVector &connectionBuses)
TTAMachine::Bus *	createBus (TTAMachine::Machine *finalMach, TCEString busName, int width)
void	createPortsAndSockets (TTAMachine::Machine *finalMach, TTAMachine::RegisterFile *rf, TTAMachine::Bus *newBus, TCEString name, bool readOnly, int nodeNumber=-1)
bool	connectVectorLSU (TTAMachine::Machine *finalMach, TTAMachine::Machine *nodeMach, TTAMachine::Machine *extraMach, int nodeCount)
void	renameExtraUnits (TTAMachine::Machine *finalMach)
TCEString	getNodeComponentName (TCEString originalName, int idx)
TCEString	getExtraComponentName (TCEString originalName)
void	copyGuards (TTAMachine::Bus &originalBus, TTAMachine::Bus &addBus, const TCEString &prefix)

Private Attributes
ComponentImplementationSelector	selector_
	Selector used by the plugin.
TCEString	node_
int	nodeCount_
TCEString	extra_
bool	buildIDF_
bool	vectorLSU_
TCEString	addressSpaces_
bool	addBroadcast_
bool	addRing_
bool	addBar_
bool	addStar_
int	nodesPerBus_
bool	reuseRFPorts_
int	sharedLSULatency_
int	dataLSULatency_
int	VLSUConnectionBuses_

Static Private Attributes
static const TCEString	NodePN_
static const TCEString	NodeCountPN_
static const TCEString	ExtraPN_
static const TCEString	BuildIDFPN_
static const TCEString	VectorLSUPN_
static const TCEString	AddressSpacesPN_
static const TCEString	AddBroadcastPN_
static const TCEString	AddRingConnectionPN_
static const TCEString	AddBarConnectionPN_
static const TCEString	AddStarConnectionPN_
static const TCEString	NodesPerBusPN_
static const TCEString	ReuseRFPortsPN_
static const TCEString	SharedLSULatencyPN_
static const TCEString	DataLSULatencyPN_
static const TCEString	VLSUConnectionBusesPN_

Additional Inherited Members
Public Types inherited from DesignSpaceExplorerPlugin
typedef std::pair< std::string, ExplorerPluginParameter >	Parameter
typedef std::map< std::string, ExplorerPluginParameter >	ParameterMap
typedef std::map< std::string, ExplorerPluginParameter >::iterator	PMIt
typedef std::map< std::string, ExplorerPluginParameter >::const_iterator	PMCIt
Public Member Functions inherited from DesignSpaceExplorerPlugin
virtual std::string	description () const
void	addParameter (TCEString name, ExplorerPluginParameterType type, bool compulsory=true, TCEString defaultValue="", TCEString description="")
template<typename T >
void	readCompulsoryParameter (const std::string paramName, T &param) const
template<typename T >
void	readOptionalParameter (const std::string paramName, T &param) const
template<typename RT >
RT	parameterValue (const std::string &paramName) const
virtual	~DesignSpaceExplorerPlugin ()
virtual void	giveParameter (const std::string &name, const std::string &value)
virtual std::string	name () const
virtual void	setPluginName (const std::string &pluginName)
virtual bool	hasParameter (const std::string &paramName) const
ParameterMap	parameters () const
virtual bool	booleanValue (const std::string &parameter) const
Public Member Functions inherited from DesignSpaceExplorer
	DesignSpaceExplorer ()
virtual	~DesignSpaceExplorer ()
virtual void	setDSDB (DSDBManager &dsdb)
virtual bool	evaluate (const DSDBManager::MachineConfiguration &configuration, CostEstimates &results=dummyEstimate_, bool estimate=false)
virtual DSDBManager &	db ()
std::vector< DesignSpaceExplorerPlugin * >	getPlugins ()
RowID	createImplementationAndStore (const DSDBManager::MachineConfiguration &conf, const double &frequency=0.0, const double &maxArea=0.0, const bool &createEstimates=true, const std::string &icDec="DefaultICDecoder", const std::string &icDecHDB="asic_130nm_1.5V.hdb")
bool	createImplementation (const DSDBManager::MachineConfiguration &conf, DSDBManager::MachineConfiguration &newConf, const double &frequency=0.0, const double &maxArea=0.0, const bool &createEstimates=true, const std::string &icDec="DefaultICDecoder", const std::string &icDecHDB="asic_130nm_1.5V.hdb")
IDF::MachineImplementation *	selectComponents (const TTAMachine::Machine &mach, const double &frequency=0.0, const double &maxArea=0.0, const std::string &icDec="DefaultICDecoder", const std::string &icDecHDB="asic_130nm_1.5V.hdb") const
void	createEstimateData (const TTAMachine::Machine &mach, const IDF::MachineImplementation &idf, CostEstimator::AreaInGates &area, CostEstimator::DelayInNanoSeconds &longestPathDelay)
RowID	addConfToDSDB (const DSDBManager::MachineConfiguration &conf)
Static Public Member Functions inherited from DesignSpaceExplorer
static DesignSpaceExplorerPlugin *	loadExplorerPlugin (const std::string &pluginName, DSDBManager *dsdb=NULL)
Protected Member Functions inherited from DesignSpaceExplorerPlugin
	DesignSpaceExplorerPlugin ()
void	checkParameters () const
Protected Member Functions inherited from DesignSpaceExplorer
TTAProgram::Program *	schedule (const std::string applicationFile, TTAMachine::Machine &machine, TCEString paramOptions="-O3")
const ExecutionTrace *	simulate (const TTAProgram::Program &program, const TTAMachine::Machine &machine, const TestApplication &testApplication, const ClockCycleCount &maxCycles, ClockCycleCount &runnedCycles, const bool tracing, const bool useCompiledSimulation=false, std::vector< ClockCycleCount > *executionCounts=NULL)
Protected Attributes inherited from DesignSpaceExplorerPlugin
std::string	pluginName_
	the name of the explorer plugin
ParameterMap	parameters_
	Parameters for the plugin.

Detailed Description

Explorer plugin that adds machine components to a given machine.

Definition at line 60 of file ADFCombiner.cc.

Member Typedef Documentation

BusVector

typedef std::vector<TTAMachine::Bus*> ADFCombiner::BusVector

private

Definition at line 297 of file ADFCombiner.cc.

GuardSet

typedef std::set<TTAMachine::Guard*, TTAMachine::MachinePart::Comparator> ADFCombiner::GuardSet

private

Definition at line 299 of file ADFCombiner.cc.

Constructor & Destructor Documentation

ADFCombiner()

ADFCombiner::ADFCombiner ( )

inlineprivate

Definition at line 65 of file ADFCombiner.cc.

                 : DesignSpaceExplorerPlugin(), 
        node_("node.adf"),
        nodeCount_(4),
        extra_(""),
        buildIDF_(false),
        vectorLSU_(false),
        addressSpaces_("data"),
        addBroadcast_(false),
        addRing_(false),
        addBar_(false),
        addStar_(true),
        nodesPerBus_(1),
        reuseRFPorts_(true),
        sharedLSULatency_(3),
        dataLSULatency_(3),
        VLSUConnectionBuses_(1000){
 
        // compulsory parameters
        // no compulsory parameters
 
        // parameters that have a default value
        addParameter(NodePN_, STRING, false, node_);
        addParameter(NodeCountPN_, UINT, false, 
            Conversion::toString(nodeCount_));
        addParameter(ExtraPN_, STRING, false, extra_);
        addParameter(BuildIDFPN_, BOOL, false, Conversion::toString(buildIDF_));
        addParameter(VectorLSUPN_, BOOL, false, 
            Conversion::toString(vectorLSU_));
 
 
        addParameter(AddressSpacesPN_, STRING, false, addressSpaces_);
        addParameter(AddBroadcastPN_, BOOL, false, 
            Conversion::toString(addBroadcast_));
        addParameter(AddRingConnectionPN_, BOOL, false, 
            Conversion::toString(addRing_));
        addParameter(AddBarConnectionPN_, BOOL, false, 
            Conversion::toString(addBar_));
        addParameter(AddStarConnectionPN_, BOOL, false, 
            Conversion::toString(addStar_));
        addParameter(NodesPerBusPN_, UINT, false, Conversion::toString(nodesPerBus_));
        addParameter(ReuseRFPortsPN_, BOOL, false, 
            Conversion::toString(reuseRFPorts_));
        
        addParameter(
            SharedLSULatencyPN_, UINT, false, Conversion::toString(sharedLSULatency_));
        addParameter(
            DataLSULatencyPN_, UINT, false, Conversion::toString(dataLSULatency_));
        addParameter(
            VLSUConnectionBusesPN_, UINT, false, Conversion::toString(VLSUConnectionBuses_));
 
        
    }

References addBar_, AddBarConnectionPN_, addBroadcast_, AddBroadcastPN_, DesignSpaceExplorerPlugin::addParameter(), addressSpaces_, AddressSpacesPN_, addRing_, AddRingConnectionPN_, addStar_, AddStarConnectionPN_, BOOL, buildIDF_, BuildIDFPN_, dataLSULatency_, DataLSULatencyPN_, extra_, ExtraPN_, node_, nodeCount_, NodeCountPN_, NodePN_, nodesPerBus_, NodesPerBusPN_, reuseRFPorts_, ReuseRFPortsPN_, sharedLSULatency_, SharedLSULatencyPN_, STRING, Conversion::toString(), UINT, vectorLSU_, VectorLSUPN_, VLSUConnectionBuses_, and VLSUConnectionBusesPN_.

Here is the call graph for this function:

Member Function Documentation

addAddressSpaces()

void ADFCombiner::addAddressSpaces ( TTAMachine::Machine *  finalMach, TTAMachine::Machine *  nodeMach  )

inlineprivate

Adds address spaces from node machine to final one, if missing. Address spaces from extra machine are already in final.

Returns

void

Definition at line 621 of file ADFCombiner.cc.

                                     {    
        
        const TTAMachine::Machine::AddressSpaceNavigator& ANav = 
            nodeMach->addressSpaceNavigator();        
        for (int i = 0; i < ANav.count(); i++) {
            TTAMachine::AddressSpace* origA = ANav.item(i);
            if (!finalMach->addressSpaceNavigator().hasItem(origA->name())) {            
                ObjectState* origState = origA->saveState();
                // Creating address space registers it.                
                TTAMachine::AddressSpace* aSpace = 
                    new TTAMachine::AddressSpace(origState, *finalMach);
                assert(
                    finalMach->addressSpaceNavigator().hasItem(aSpace->name()));
            }
        }        
    }

References TTAMachine::Machine::addressSpaceNavigator(), assert, TTAMachine::Machine::Navigator< ComponentType >::count(), TTAMachine::Machine::Navigator< ComponentType >::hasItem(), TTAMachine::Machine::Navigator< ComponentType >::item(), TTAMachine::Component::name(), and TTAMachine::AddressSpace::saveState().

Referenced by addComponents().

Here is the call graph for this function:

addAllGuardsToConnectionBuses()

void ADFCombiner::addAllGuardsToConnectionBuses ( TTAMachine::Machine *  finalMach, const BusVector &  connectionBuses  )

inlineprivate

Definition at line 361 of file ADFCombiner.cc.

                                          {
        for (BusVector::const_iterator i = connectionBuses.begin(); 
             i != connectionBuses.end(); ++i) {
            const TTAMachine::Machine::BusNavigator& busNav =
                finalMach->busNavigator();
            Bus* connectionBus = *i;            
            for (int b = 0; b < busNav.count(); b++) {
                Bus* origBus = busNav.item(b);
                origBus->copyGuardsTo(*connectionBus);
            }
        }
 
    }

References TTAMachine::Machine::busNavigator(), TTAMachine::Bus::copyGuardsTo(), TTAMachine::Machine::Navigator< ComponentType >::count(), and TTAMachine::Machine::Navigator< ComponentType >::item().

Referenced by addComponents().

Here is the call graph for this function:

addBuses()

void ADFCombiner::addBuses ( TTAMachine::Machine *  finalMach, TTAMachine::Machine *  nodeMach, unsigned  nodeCount, std::map< Bus *, std::pair< Bus *, int > > &  busMapping  )

inlineprivate

Adds buses and sockets to the machine.

Definition at line 399 of file ADFCombiner.cc.

                                                       {
        const Machine::SocketNavigator socketNav = nodeMach->socketNavigator();
        const TTAMachine::Machine::BusNavigator& busNav = 
            nodeMach->busNavigator();
        
        for (unsigned j = 0; j < nodeCount; j++) {
            bool socketsCreated = false;
            // Add busses
            for (int i = 0; i < busNav.count(); i++) {
                TTAMachine::Bus* addBus = busNav.item(i)->copy();
                TTAMachine::Bus* originalBus = busNav.item(i);
                busMapping[addBus] = std::pair<Bus*,int>(originalBus, j);
 
                TCEString busName = 
                    originalBus->name() + "_connect_" + Conversion::toString(j);
                addBus->setName(busName);
                try {
                    finalMach->addBus(*addBus);
                } catch (const ComponentAlreadyExists& e) {
                    TCEString msg = "ADFCombiner: Tried to add Bus with an "
                        "already existing name (" + busName + ")";
                    throw Exception(
                        __FILE__, __LINE__, __func__, msg);
                }
 
                for (int k = 0; k < socketNav.count(); k++) {
                    TTAMachine::Socket* addSocket = NULL;
                    if (socketNav.item(k)->portCount() == 0) {
                        // Don't bother copying sockets that are not connected
                        // to any ports.
                        continue;
                    }
                    // When first bus added, create also new sockets
                    if (!socketsCreated) {                        
                        TCEString socketName = 
                            getNodeComponentName(socketNav.item(k)->name(), j);
                        addSocket = new TTAMachine::Socket(socketName);   
                        try {     
                            finalMach->addSocket(*addSocket);
                        } catch (const ComponentAlreadyExists& e) {
                            TCEString msg = "ADFCombiner: Tried to add Socket with "
                            " an already existing name (" + socketName +")";
                            throw Exception(
                                __FILE__, __LINE__, __func__, msg);                            
                        }
                    } else {
                        // Sockets were create for first bus already, just pick
                        // them based on their known generated names.
                        TCEString socketName = 
                            getNodeComponentName(socketNav.item(k)->name(), j);
                        addSocket = 
                            finalMach->socketNavigator().item(socketName);
                    }
                    // Connect sockets to bus
                    for (int l = 0; l < originalBus->segmentCount(); l++) {
                        if (socketNav.item(k)->isConnectedTo(
                            *originalBus->segment(l))) {
                            addSocket->attachBus(*addBus->segment(l));
                            addSocket->setDirection(
                                socketNav.item(k)->direction());
                        }
                    }
                }
                socketsCreated = true;                
            }
        }
    }                

References __func__, TTAMachine::Machine::addBus(), TTAMachine::Machine::addSocket(), TTAMachine::Socket::attachBus(), TTAMachine::Machine::busNavigator(), TTAMachine::Machine::Navigator< ComponentType >::count(), getNodeComponentName(), TTAMachine::Machine::Navigator< ComponentType >::item(), TTAMachine::Component::name(), TTAMachine::Bus::segment(), TTAMachine::Bus::segmentCount(), TTAMachine::Socket::setDirection(), TTAMachine::Bus::setName(), TTAMachine::Machine::socketNavigator(), and Conversion::toString().

Referenced by addComponents().

Here is the call graph for this function:

addComponents()

void ADFCombiner::addComponents ( TTAMachine::Machine *  finalMach, TTAMachine::Machine *  nodeMach, TTAMachine::Machine *  extraMach, unsigned  nodeCount  )

inlineprivate

Copies node.adf to the final machine nodeCount times.

Returns

The initial machine of NULL if an error occurred.

Definition at line 320 of file ADFCombiner.cc.

                            {
        
        std::map<Bus*, std::pair<Bus*, int> > busMapping;
        // Order is important here!
        // When adding busses also socket will be created
        // and the RF and FU ports will be connected to them when adding.
 
        // find guards that have come from extras
        GuardSet extrasGuards = findGuards(finalMach);
 
        renameExtraUnits(finalMach);
        addAddressSpaces(finalMach, nodeMach);
        if (extraMach != NULL)
            addAddressSpaces(finalMach, extraMach);                        
        addBuses(finalMach, nodeMach, nodeCount, busMapping);
        addRegisterFiles(finalMach, nodeMach, nodeCount);
        addFunctionUnits(finalMach, nodeMach, nodeCount);     
 
        BusVector connectionBuses;
        connectRegisterFiles(
            finalMach, nodeMach, extraMach, nodeCount, extrasGuards,
            connectionBuses);
        addGuardsToBuses(busMapping, extrasGuards);
 
        /* For the node-only machine, copy the guards from the nodes to the
           connection buses to enable predicated inter-node moves. */
        if (extra_ == "")
            addAllGuardsToConnectionBuses(finalMach, connectionBuses);
    }

References addAddressSpaces(), addAllGuardsToConnectionBuses(), addBuses(), addFunctionUnits(), addGuardsToBuses(), addRegisterFiles(), connectRegisterFiles(), extra_, findGuards(), and renameExtraUnits().

Referenced by explore().

Here is the call graph for this function:

addFunctionUnits()

void ADFCombiner::addFunctionUnits ( TTAMachine::Machine *  finalMach, TTAMachine::Machine *  nodeMach, unsigned  nodeCount  )

inlineprivate

Adds function unit(s) to the machine

Returns

void

Definition at line 511 of file ADFCombiner.cc.

                                                         {
        const TTAMachine::Machine::FunctionUnitNavigator& FUNav = 
            nodeMach->functionUnitNavigator();        
        for (unsigned j = 0; j < nodeCount; j++) {
            for (int i = 0; i < FUNav.count(); i++) {
                TTAMachine::FunctionUnit* addFU = FUNav.item(i)->copy();
                TTAMachine::FunctionUnit* originalFU = FUNav.item(i);                
                TCEString FUName = 
                    getNodeComponentName(FUNav.item(i)->name(), j);
                addFU->setName(FUName);                
                try {     
                    finalMach->addFunctionUnit(*addFU);
                } catch (const ComponentAlreadyExists& e) {
                    TCEString msg = 
                        "ADFCombiner: Tried to add FU with an already"
                        "existing name (" + FUName +")";
                    throw Exception(
                        __FILE__, __LINE__, __func__, msg);
                }
                if (originalFU->hasAddressSpace()) {
                    TCEString aName = originalFU->addressSpace()->name();
                    const TTAMachine::Machine::AddressSpaceNavigator& aNav = 
                        finalMach->addressSpaceNavigator();
                    assert(aNav.hasItem(aName));
                    addFU->setAddressSpace(aNav.item(aName));
                }
                connectPorts(finalMach, originalFU, addFU, j);
            }
        }
 
        if (extra_ == "") {
            TTAMachine::ControlUnit *originalCU = nodeMach->controlUnit();
            TTAMachine::ControlUnit *copyCU = originalCU->copy();
            finalMach->setGlobalControl(*copyCU);
            if (originalCU->hasAddressSpace()) {
                TCEString aName = originalCU->addressSpace()->name();
                const TTAMachine::Machine::AddressSpaceNavigator& aNav = 
                    finalMach->addressSpaceNavigator();
                assert(aNav.hasItem(aName));
                copyCU->setAddressSpace(aNav.item(aName));
 
                // Connect the CU to all node 0 buses for now. 
                // @todo remove the connections not to RFs and
                // ensure the buses are guarded
                FullyConnectedCheck conn;
                conn.connectControlUnit(*copyCU);
            }
            
        }
    }

References __func__, TTAMachine::Machine::addFunctionUnit(), TTAMachine::FunctionUnit::addressSpace(), TTAMachine::Machine::addressSpaceNavigator(), assert, FullyConnectedCheck::connectControlUnit(), connectPorts(), TTAMachine::Machine::controlUnit(), TTAMachine::ControlUnit::copy(), TTAMachine::Machine::Navigator< ComponentType >::count(), extra_, TTAMachine::Machine::functionUnitNavigator(), getNodeComponentName(), TTAMachine::FunctionUnit::hasAddressSpace(), TTAMachine::Machine::Navigator< ComponentType >::hasItem(), TTAMachine::Machine::Navigator< ComponentType >::item(), TTAMachine::Component::name(), TTAMachine::FunctionUnit::setAddressSpace(), TTAMachine::Machine::setGlobalControl(), and TTAMachine::FunctionUnit::setName().

Referenced by addComponents().

Here is the call graph for this function:

addGuardsToBuses()

void ADFCombiner::addGuardsToBuses ( std::map< Bus *, std::pair< Bus *, int > > &  busMapping, GuardSet &  extrasGuards  )

inlineprivate

Definition at line 378 of file ADFCombiner.cc.

                                             {
        for (std::map<Bus*, std::pair<Bus*, int> >::iterator i =
                 busMapping.begin(); i != busMapping.end(); i++) {
            
            copyGuards(*(i->second.first), *(i->first), nodeNamePrefix(i->second.second));
            
            for (GuardSet::iterator j = extrasGuards.begin();
                 j != extrasGuards.end(); j++) {
                if (!i->first->hasGuard(**j)) {
                    (*j)->copyTo(*i->first);
                }
            }
        }
    }

References copyGuards(), and nodeNamePrefix().

Referenced by addComponents().

Here is the call graph for this function:

addRegisterFiles()

void ADFCombiner::addRegisterFiles ( TTAMachine::Machine *  finalMach, TTAMachine::Machine *  nodeMach, unsigned  nodeCount  )

inlineprivate

Adds register file(s) to the machine

Returns

void

Definition at line 478 of file ADFCombiner.cc.

                                                         {
        
        const TTAMachine::Machine::RegisterFileNavigator& RFNav = 
            nodeMach->registerFileNavigator();        
        for (unsigned j = 0; j < nodeCount; j++) {
            for (int i = 0; i < RFNav.count(); i++) {
                TTAMachine::RegisterFile* addRF = RFNav.item(i)->copy();
                TTAMachine::RegisterFile* originalRF = RFNav.item(i);
                TCEString RFName = 
                    getNodeComponentName(RFNav.item(i)->name(), j);                    
                addRF->setName(RFName);
                try {     
                    finalMach->addRegisterFile(*addRF);
                } catch (const ComponentAlreadyExists& e) {
                    TCEString msg = 
                        "ADFCombiner: Tried to add RF with an already"
                        "existing name (" + RFName +")";
                    throw Exception(
                        __FILE__, __LINE__, __func__, msg);
                }
                connectPorts(finalMach, originalRF, addRF, j);
            }
        }
    }

References __func__, TTAMachine::Machine::addRegisterFile(), connectPorts(), TTAMachine::Machine::Navigator< ComponentType >::count(), getNodeComponentName(), TTAMachine::Machine::Navigator< ComponentType >::item(), TTAMachine::Machine::registerFileNavigator(), and TTAMachine::RegisterFile::setName().

Referenced by addComponents().

Here is the call graph for this function:

connectPorts()

void ADFCombiner::connectPorts ( TTAMachine::Machine *  finalMach, TTAMachine::Unit *  original, TTAMachine::Unit *  newUnit, int  count  )

inlineprivate

Connect unit ports to sockets.

Returns

void

Definition at line 571 of file ADFCombiner.cc.

                   {
        
        for (int k = 0; k < original->portCount(); k++) {
            TTAMachine::Port* port = original->port(k);
            TTAMachine::Socket* socket = port->inputSocket();
            if (socket != NULL) {
                TCEString socketName = 
                    getNodeComponentName(socket->name(), count);                
                TTAMachine::Socket* newSocket = 
                    finalMach->socketNavigator().item(socketName);
                newUnit->port(k)->attachSocket(*newSocket);
            }
            socket = port->outputSocket();
            if (socket != NULL) {
                TCEString socketName = 
                    getNodeComponentName(socket->name(), count);                
                TTAMachine::Socket* newSocket = 
                    finalMach->socketNavigator().item(socketName);
                newUnit->port(k)->attachSocket(*newSocket);                        
            }
            socket = port->unconnectedSocket(0);
            if (socket != NULL) {
                TCEString socketName =                     
                    getNodeComponentName(socket->name(), count);                
                TTAMachine::Socket* newSocket = 
                    finalMach->socketNavigator().item(socketName);
                newUnit->port(k)->attachSocket(*newSocket);                        
            }
            socket = port->unconnectedSocket(1);
            if (socket != NULL) {
                TCEString socketName = 
                    getNodeComponentName(socket->name(), count);                
                TTAMachine::Socket* newSocket = 
                    finalMach->socketNavigator().item(socketName);
                newUnit->port(k)->attachSocket(*newSocket);                        
            }                    
        }        
    }

References TTAMachine::Port::attachSocket(), getNodeComponentName(), TTAMachine::Port::inputSocket(), TTAMachine::Machine::Navigator< ComponentType >::item(), TTAMachine::Component::name(), TTAMachine::Port::outputSocket(), TTAMachine::Unit::port(), TTAMachine::Unit::portCount(), TTAMachine::Machine::socketNavigator(), and TTAMachine::Port::unconnectedSocket().

Referenced by addFunctionUnits(), and addRegisterFiles().

Here is the call graph for this function:

connectRegisterFiles()

void ADFCombiner::connectRegisterFiles ( TTAMachine::Machine *  finalMach, TTAMachine::Machine *  nodeMach, TTAMachine::Machine *  extraMach, unsigned  nodeCount, std::set< TTAMachine::Guard *, TTAMachine::MachinePart::Comparator >  extrasGuards, BusVector &  connectionBuses  )

inlineprivate

Connect register files from extra and node into a ring, star or bar.

Definition at line 645 of file ADFCombiner.cc.

                                    {
 
        const TTAMachine::Machine::RegisterFileNavigator& nodeNav =
            nodeMach->registerFileNavigator();
        const TTAMachine::Machine::RegisterFileNavigator& finalNav =
            finalMach->registerFileNavigator();
                    
        const TTAMachine::Machine::ImmediateUnitNavigator& finalImmNav =
            finalMach->immediateUnitNavigator();
            
        const TTAMachine::Machine::BusNavigator& busNav =
            finalMach->busNavigator();
        if (addRing_) {
            for (int i = 0; i < nodeNav.count(); i++) {
                TCEString rfName = nodeNav.item(i)->name();            
                // Connect register file between neighbouring node
                for (unsigned int j = 0; j < nodeCount -1; j++) {        
                    TCEString firstName = getNodeComponentName(rfName, j);
                    TCEString secondName = getNodeComponentName(rfName, j+1);
                    TTAMachine::RegisterFile* firstRF = finalNav.item(firstName);
                    TTAMachine::RegisterFile* secondRF = finalNav.item(secondName);                
                    
                    TCEString busName = "connect_"
                        + Conversion::toString(j) +
                        "_" + Conversion::toString(j + 1);
                    int width = std::max(firstRF->width(), secondRF->width());
                    TTAMachine::Bus* newBus = NULL;
                    
                    if (busNav.hasItem(busName)) {
                        newBus = busNav.item(busName);
                    } else {
                        newBus = createBus(finalMach, busName, width);
                    }
                    connectionBuses.push_back(newBus);
 
                    // Copy guards from extras to neighbour connection buses.
                    for (GuardSet::iterator k = extrasGuards.begin();
                        k != extrasGuards.end(); k++) {
                        if (!newBus->hasGuard(**k)) {
                            (*k)->copyTo(*newBus);
                        }
                    }
                    createPortsAndSockets(
                        finalMach, firstRF, newBus, firstName, false);
                    createPortsAndSockets(
                        finalMach, secondRF, newBus, secondName, false);                
                }
 
                // A clustered machine without an extras node.
                if (extraMach == NULL) continue;
 
                const TTAMachine::Machine::RegisterFileNavigator& extraNav =
                    extraMach->registerFileNavigator();
 
                // Add connections between RF in extra.adf with first and
                // last of the multiplied nodes
                TCEString firstName = getNodeComponentName(rfName, 0);
                TCEString lastName = getNodeComponentName(rfName, nodeCount -1);
                TTAMachine::RegisterFile* firstRF = finalNav.item(firstName);
                TTAMachine::RegisterFile* lastRF = finalNav.item(lastName);                
                    
                for (int k = 0; k < extraNav.count(); k++) {
                    TCEString newName = 
                        getExtraComponentName(extraNav.item(k)->name());                
                    TTAMachine::RegisterFile* extraRF = finalNav.item(newName);                
                    if (extraRF->width() != firstRF->width()) {
                        continue;
                    }
                    TCEString extraName = extraRF->name();
                    int width = std::max(firstRF->width(), extraRF->width());
                    TCEString busName = "connect_extra_first";
                    TTAMachine::Bus* newBus = NULL;
                    if (busNav.hasItem(busName)) {
                        newBus = busNav.item(busName);
                    } else {
                        newBus = createBus(finalMach, busName, width);
                    }
                    for (GuardSet::iterator j = extrasGuards.begin();
                        j != extrasGuards.end(); j++) {
                        if (!newBus->hasGuard(**j)) {
                            (*j)->copyTo(*newBus);
                        }
                    }
                    createPortsAndSockets(
                        finalMach, firstRF, newBus, firstName, false);
                    createPortsAndSockets(
                        finalMach, extraRF, newBus, extraName, false);                
                    // In case we only one node, there is no need to bidirectional
                    // connection
                    if (firstName != lastName) {
                        width = std::max(lastRF->width(), extraRF->width());
                        busName = "connect_extra_last";
                        if (busNav.hasItem(busName)) {
                            newBus = busNav.item(busName);
                        } else {
                            newBus = createBus(finalMach, busName, width);
                        }                        
                        for (GuardSet::iterator j = extrasGuards.begin(); 
                            j != extrasGuards.end(); j++) {
                            if (!newBus->hasGuard(**j)) {
                                (*j)->copyTo(*newBus);
                            }
                        }                
                        createPortsAndSockets(
                            finalMach, lastRF, newBus, lastName, false);
                        createPortsAndSockets(
                            finalMach, extraRF, newBus, extraName, false);                                
                    }
                }                
            }        
        }
        if (addBar_) {
            int busCount = nodeCount;
            for (int i = 0; i < busCount; i++) {                    
                TCEString busName = 
                    "connect_all_" + Conversion::toString(i);
 
                TTAMachine::Bus* newBus = createBus(finalMach, busName, 32);
                connectionBuses.push_back(newBus);
 
                for (int i = 0; i < nodeNav.count(); i++) {
                    // Pick all register files in node, one by one
                    TCEString rfName = nodeNav.item(i)->name();            
                    for (unsigned int j = 0; j < nodeCount; j++) {        
                        // connect register file from all node to the
                        // bus
                        TCEString nodeName = 
                            getNodeComponentName(rfName, j);                            
                        TTAMachine::RegisterFile* nodeRF = 
                            finalNav.item(nodeName);                                            
                        createPortsAndSockets(
                            finalMach, nodeRF, newBus, nodeName, false);
                    }
                }
 
                if (extraMach == NULL) continue;
 
                const TTAMachine::Machine::RegisterFileNavigator& extraNav =
                    extraMach->registerFileNavigator();
            
                for (int k = 0; k < extraNav.count(); k++) {
                    TCEString newName = 
                        getExtraComponentName(extraNav.item(k)->name());                
                    TTAMachine::RegisterFile* extraRF = finalNav.item(newName);                
                    TCEString extraName = extraRF->name();
                    int width = extraRF->width();
                    if (width == 1)
                        continue;                
                                    
                    createPortsAndSockets(finalMach, extraRF, newBus, extraName, false);
                    for (GuardSet::iterator j = extrasGuards.begin();
                        j != extrasGuards.end(); j++) {
                        if (!newBus->hasGuard(**j)) {
                            (*j)->copyTo(*newBus);
                        }
                    }
                }
 
                const TTAMachine::Machine::ImmediateUnitNavigator& extraImmNav =
                    extraMach->immediateUnitNavigator();
 
 
                for (int k = 0; k < extraImmNav.count(); k++) {
                    TCEString newName = 
                        getExtraComponentName(extraImmNav.item(k)->name());                
                    TTAMachine::ImmediateUnit* extraImm = finalImmNav.item(newName);                
                    TCEString extraName = extraImm->name();
                    int width = extraImm->width();
                    if (width == 1)
                        continue;                
                                    
                    createPortsAndSockets(
                        finalMach, extraImm, newBus, extraName, true);
                    for (GuardSet::iterator j = extrasGuards.begin();
                        j != extrasGuards.end(); j++) {
                        if (!newBus->hasGuard(**j)) {
                            (*j)->copyTo(*newBus);
                        }
                    }
                }                
            }                            
        }
        if (addStar_) {
            if (extraMach != NULL) {
                const TTAMachine::Machine::RegisterFileNavigator& extraNav =
                    extraMach->registerFileNavigator();
 
                for (unsigned int i = 0; i*nodesPerBus_ < nodeCount; i++) {
                    TCEString busName =
                        "star_" + Conversion::toString(i);
                    TTAMachine::Bus* newBus = 
                        createBus(finalMach, busName, 32);
                    connectionBuses.push_back(newBus);
                    // Connect RFs in extra to the bus
                    for (int k = 0; k < extraNav.count(); k++) {
                        TCEString newName =
                            getExtraComponentName(extraNav.item(k)->name());
                        TTAMachine::RegisterFile* extraRF = 
                            finalNav.item(newName);
                        TCEString extraName = extraRF->name();
                        int width = extraRF->width();
                        if (width == 1)
                            continue;
                        
                        createPortsAndSockets(
                            finalMach, extraRF, newBus, extraName, false, i);                                                    
                        for (GuardSet::iterator j = extrasGuards.begin();
                             j != extrasGuards.end(); j++) {
                            if (!newBus->hasGuard(**j)) {
                                (*j)->copyTo(*newBus);
                            }
                        }
                    } 
                    
                    for (int j = 0; j < nodeNav.count(); j++) {
                        // Pick all register files in node, one by one
                        TCEString rfName = nodeNav.item(j)->name();
                        for (int k = 0; 
                             k < nodesPerBus_ && (i*nodesPerBus_)+k 
                                 < nodeCount; k++) {
                            TCEString nodeName =
                                getNodeComponentName(
                                    rfName, ((i*nodesPerBus_)+k));
                            TTAMachine::RegisterFile* nodeRF =
                                finalNav.item(nodeName);
                            createPortsAndSockets(
                                finalMach, nodeRF, newBus, nodeName, false);
                        }
                    }
 
                    const TTAMachine::Machine::ImmediateUnitNavigator& extraImmNav =
                        extraMach->immediateUnitNavigator();
                
                    for (int k = 0; k < extraImmNav.count(); k++) {
                        TCEString newName = 
                            getExtraComponentName(extraImmNav.item(k)->name());                
                        TTAMachine::ImmediateUnit* extraImm = finalImmNav.item(newName);                
                        TCEString extraName = extraImm->name();
                        int width = extraImm->width();
                        if (width == 1)
                            continue;                
                        
                        createPortsAndSockets(
                            finalMach, extraImm, newBus, extraName, true);
                        for (GuardSet::iterator j = extrasGuards.begin();
                             j != extrasGuards.end(); j++) {
                            if (!newBus->hasGuard(**j)) {
                                (*j)->copyTo(*newBus);
                            }
                        }
                    }                                
 
                }
            } else { // extrasless - connect all to lane 0
 
                for (unsigned int i = 0; i*nodesPerBus_ < nodeCount-1; i++) {
                    TCEString busName =
                        "star_" + Conversion::toString(i);
                    TTAMachine::Bus* newBus = 
                        createBus(finalMach, busName, 32);
                    connectionBuses.push_back(newBus);
 
                    for (int j = 0; j < nodeNav.count(); j++) {
                        // Pick all register files in node, one by one
                        TCEString rfName = nodeNav.item(j)->name();
                        for (int k = 0; 
                             k < nodesPerBus_ && (i*nodesPerBus_)+k 
                                 < nodeCount-1; k++) {
                            TCEString nodeName = 
                                getNodeComponentName(
                                    rfName, ((i*nodesPerBus_)+k+1));
                            TTAMachine::RegisterFile* nodeRF =
                                finalNav.item(nodeName);
                            createPortsAndSockets(
                                finalMach, nodeRF, newBus, nodeName, false);
                        }
                    }
 
 
                    for (int j = 0; j < nodeNav.count(); j++) {
                        // Pick all register files in node, one by one
                        TCEString rfName = nodeNav.item(j)->name();            
                        TCEString node0Name = 
                            getNodeComponentName(rfName, 0);
                        TTAMachine::RegisterFile* node0RF = 
                        finalNav.item(node0Name);
                        int width = node0RF->width();
                        if (width == 1)
                            continue;                
                    
                        createPortsAndSockets(
                            finalMach, node0RF, newBus, node0Name, false, i);
 
                    }
                }
            }
        }
    }

References addBar_, addRing_, addStar_, TTAMachine::Machine::busNavigator(), TTAMachine::Machine::Navigator< ComponentType >::count(), createBus(), createPortsAndSockets(), getExtraComponentName(), getNodeComponentName(), TTAMachine::Bus::hasGuard(), TTAMachine::Machine::Navigator< ComponentType >::hasItem(), TTAMachine::Machine::immediateUnitNavigator(), TTAMachine::Machine::Navigator< ComponentType >::item(), TTAMachine::Component::name(), nodesPerBus_, TTAMachine::Machine::registerFileNavigator(), Conversion::toString(), and TTAMachine::BaseRegisterFile::width().

Referenced by addComponents().

Here is the call graph for this function:

connectVectorLSU()

bool ADFCombiner::connectVectorLSU ( TTAMachine::Machine *  finalMach, TTAMachine::Machine *  nodeMach, TTAMachine::Machine *  extraMach, int  nodeCount  )

inlineprivate

If extra has LSU that is not connected to any of the buses, treat it as a vector LSU and connect address write port to extra and data ports to respective number of nodes.

The name of bus is generated same way as when creating new buses for nodes. Any change there must be reflected here as well! In case LSU has more ports then there are nodes we start from beginning.

The name of bus is generated same way as when creating new buses for nodes. Any change there must be reflected here as well! In case LSU has more ports then there are nodes we start from beginning.

Definition at line 1110 of file ADFCombiner.cc.

                      {
        
        const TTAMachine::Machine::FunctionUnitNavigator& finalNav =
            finalMach->functionUnitNavigator();
        TTAMachine::FunctionUnit* vectorLSU = NULL;
        TTAMachine::FUPort* trigger = NULL;
        TTAMachine::FUPort* inExtra = NULL;
        TTAMachine::FUPort* outExtra = NULL;
        int triggerIndex = -1;
        int outputPortCount = 0;
        bool broadcastUnit = false;
        for (int i = 0; i < finalNav.count(); i++) {
            TTAMachine::FunctionUnit* fu = finalNav.item(i);
            bool unconnected = false;
            for(int j = 0; j < fu->operationPortCount(); j++) {
                if (fu->operationPort(j)->socketCount() == 0) {
                    unconnected = true;    
                    outputPortCount++;
                    if (fu->operationPort(j)->isTriggering()) {
                        triggerIndex = j;
                    }
                } else {
                    unconnected = false;
                    triggerIndex = -1;
                }
            }
            if (unconnected) {
            // We found FU in extra that is not connected to any sockets,
            // that is agreed indication that is it vector load/store and
            // needs specific connectivity.
            // Let's check if it has address space
                if (fu->hasAddressSpace()) {
                    // Ok, it seems to be load/store we look for, stop looking.
                    // Find equivalends in final architecture
                    vectorLSU = fu;                                    
                    trigger = vectorLSU->operationPort(triggerIndex);
                    break;
                } else if (addBroadcast_){
                    // We enabled addition of broadcast unit, so there is
                    // unit without the address space.
                    vectorLSU = fu;                                    
                    trigger = vectorLSU->operationPort(triggerIndex);
                    broadcastUnit = true;
                    break;                    
                } else {
                    verboseLog("Candidate for Vector LSU does not have "
                    "address space defined - " + fu->name());
                }
            }
        }
        if (vectorLSU == NULL) {
            // No unconnected vector LSU found, nothing to do here.
            return false;
        }
        
        assert(trigger != NULL);
        TCEString prefix = vectorLSU->name();
        TTAMachine::Socket* triggerSocket = 
            new TTAMachine::Socket(prefix + "_" + trigger->name());  
        TTAMachine::Socket* inExtraSocket = NULL;
        if (inExtra)
            inExtraSocket =
                new TTAMachine::Socket(prefix + "_" + inExtra->name());  
        TTAMachine::Socket* outExtraSocket = NULL;                
        if (outExtra)
            outExtraSocket =
                new TTAMachine::Socket(prefix + "_" + outExtra->name());  
                          
        try {     
            finalMach->addSocket(*triggerSocket);
        } catch (const ComponentAlreadyExists& e) {
            TCEString msg = 
                "ADFCombiner: Tried to add Socket with "
                " an already existing name (" + triggerSocket->name() +")";
            throw Exception(
                __FILE__, __LINE__, __func__, msg);                            
        }        
        trigger->attachSocket(*triggerSocket);
        if (inExtra) {
            try {
                finalMach->addSocket(*inExtraSocket);            
            } catch (const ComponentAlreadyExists& e) {
                TCEString msg = 
                    "ADFCombiner: Tried to add Socket with "
                    " an already existing name (" + inExtraSocket->name() +")";
                throw Exception(
                    __FILE__, __LINE__, __func__, msg);                            
            }        
            inExtra->attachSocket(*inExtraSocket);
        }
        if (outExtra) {
            try {
                finalMach->addSocket(*outExtraSocket);
            } catch (const ComponentAlreadyExists& e) {
                TCEString msg = 
                "ADFCombiner: Tried to add Socket with "
                " an already existing name (" + outExtraSocket->name() +")";
                throw Exception(
                    __FILE__, __LINE__, __func__, msg);                            
            }        
            outExtra->attachSocket(*outExtraSocket);
        }        
        
        const TTAMachine::Machine::BusNavigator& extraBusNav = 
            extraMach->busNavigator();
        const TTAMachine::Machine::BusNavigator& nodeBusNav = 
            nodeMach->busNavigator();            
        const TTAMachine::Machine::BusNavigator& finalBusNav = 
            finalMach->busNavigator();            
        // Connect trigger socket to all the buses in extra.
        for (int i = 0; i < extraBusNav.count(); i++) {
            TCEString busName = extraBusNav.item(i)->name();
            if (i>VLSUConnectionBuses_)
                continue;
            triggerSocket->attachBus(*finalBusNav.item(busName)->segment(0));
            if (inExtra)
                inExtraSocket->attachBus(*finalBusNav.item(busName)->segment(0));                            
            if (outExtra)
                outExtraSocket->attachBus(*finalBusNav.item(busName)->segment(0));            
        }
        triggerSocket->setDirection(Socket::INPUT);    
        if (inExtra)
            inExtraSocket->setDirection(Socket::INPUT);
        if (outExtra)
            outExtraSocket->setDirection(Socket::OUTPUT);
        
 
        for (int j = 0; j < vectorLSU->operationCount(); j++) {
            // We run this for all the HW operations, so some 
            // sockets port connections could already exists            
            TTAMachine::HWOperation* operation = vectorLSU->operation(j);
            TTAMachine::ExecutionPipeline* pipeline = operation->pipeline();
            
            // connect write ports to nodes.            
            TTAMachine::ExecutionPipeline::OperandSet readOperandSet =
                pipeline->readOperands();
            TTAMachine::ExecutionPipeline::OperandSet::iterator it =
                readOperandSet.begin();
            bool writeConnectedToExtra = false;
            for (; it != readOperandSet.end(); it++) {
                TTAMachine::Port* port = operation->port(*it);               
                if (port != trigger && port != inExtra) {
                    // Trigger is already connected to extra, we just connect
                    // rest of writing ports.
                    TCEString socketName = prefix + "_" + port->name();
                    TTAMachine::Socket* inputSocket = NULL;                        
                    if (!finalMach->socketNavigator().hasItem(socketName)) {
                        inputSocket = 
                            new TTAMachine::Socket(prefix + "_" + port->name());                
                        try {     
                            finalMach->addSocket(*inputSocket);
                        } catch (const ComponentAlreadyExists& e) {
                            TCEString msg = 
                            "ADFCombiner: Tried to add Socket with "
                            " an already existing name (" + inputSocket->name() +")";
                            throw Exception(
                                __FILE__, __LINE__, __func__, msg);                            
                        }        
                    } else {
                        inputSocket = 
                            finalMach->socketNavigator().item(socketName);
                    }
                    if (!port->isConnectedTo(*inputSocket)){
                        port->attachSocket(*inputSocket);
                    }
                    for (int i = 0; i < nodeBusNav.count(); i++) {
                        /// The name of bus is generated same way as when creating
                        /// new buses for nodes. Any change there must be reflected
                        /// here as well!
                        /// In case LSU has more ports then there are nodes
                        /// we start from beginning.
                        // Operand index 1 is trigger, usefull operand
                        // indexes starts from 2, node counting starts from 0
                        TCEString busName = 
                            nodeBusNav.item(i)->name() + "_connect_" + 
                            Conversion::toString((*it -2) % nodeCount);
                        assert(finalBusNav.hasItem(busName));
                        if (i>VLSUConnectionBuses_)
                            continue;
                        if (!inputSocket->isConnectedTo(
                            *finalBusNav.item(busName)->segment(0))) {
                            inputSocket->attachBus(
                                *finalBusNav.item(busName)->segment(0));                            
                        }
                    }
                    if (!writeConnectedToExtra) {
                        for (int i = 0; i < extraBusNav.count(); i++) {
                            TCEString busName = extraBusNav.item(i)->name();
                            if (i>VLSUConnectionBuses_)
                                continue;
                            if (!inputSocket->isConnectedTo(
                                *finalBusNav.item(busName)->segment(0)))
                                inputSocket->attachBus(
                                    *finalBusNav.item(busName)->segment(0));                            
                        }
                        writeConnectedToExtra = true;
                    }
                    inputSocket->setDirection(Socket::INPUT);                                                                    
                }
            }
            // connect read ports to nodes.            
            TTAMachine::ExecutionPipeline::OperandSet writeOperandSet =
                pipeline->writtenOperands();
            it = writeOperandSet.begin();
            bool readConnectedToExtra = false;
            for (; it != writeOperandSet.end(); it++) {
                TTAMachine::Port* port = operation->port(*it);  
                if (port == outExtra)
                    continue;
                assert(port != trigger);
                TCEString socketName = prefix + "_" + port->name();
                TTAMachine::Socket* outputSocket = NULL;                        
                if (!finalMach->socketNavigator().hasItem(socketName)) {
                    outputSocket = 
                        new TTAMachine::Socket(prefix + "_" + port->name());                
                    try {     
                        finalMach->addSocket(*outputSocket);
                    } catch (const ComponentAlreadyExists& e) {
                        TCEString msg = 
                        "ADFCombiner: Tried to add Socket with "
                        " an already existing name (" + outputSocket->name() +")";
                        throw Exception(
                            __FILE__, __LINE__, __func__, msg);                            
                    }        
                } else {
                    outputSocket = 
                        finalMach->socketNavigator().item(socketName);
                }
                if (!port->isConnectedTo(*outputSocket)){
                    port->attachSocket(*outputSocket);
                }
                for (int i = 0; i < nodeBusNav.count(); i++) {
                    /// The name of bus is generated same way as when creating
                    /// new buses for nodes. Any change there must be reflected
                    /// here as well!
                    /// In case LSU has more ports then there are nodes
                    /// we start from beginning.
                    // Operand index 1 is trigger, usefull operand
                    // indexes starts from 2, node counting starts from 0                    
                    TCEString busName = 
                        nodeBusNav.item(i)->name() + "_connect_" + 
                        Conversion::toString((*it -2) % nodeCount);
                    assert(finalBusNav.hasItem(busName));
                    if (i>VLSUConnectionBuses_)
                        continue;
                    if (!outputSocket->isConnectedTo(
                            *finalBusNav.item(busName)->segment(0))) {
                        outputSocket->attachBus(
                            *finalBusNav.item(busName)->segment(0));                            
                    }
                }
                if (!readConnectedToExtra && !broadcastUnit) {
                    for (int i = 0; i < extraBusNav.count(); i++) {
                        TCEString busName = extraBusNav.item(i)->name();
                        if (i>VLSUConnectionBuses_)
                            continue;
                        if (!outputSocket->isConnectedTo(
                            *finalBusNav.item(busName)->segment(0)))
                            outputSocket->attachBus(
                                *finalBusNav.item(busName)->segment(0));                            
                    }
                    readConnectedToExtra = true;
                }
                outputSocket->setDirection(Socket::OUTPUT);                                                                    
            }
        } 
        return true;
    }

References __func__, addBroadcast_, TTAMachine::Machine::addSocket(), assert, TTAMachine::Socket::attachBus(), TTAMachine::Port::attachSocket(), TTAMachine::Machine::busNavigator(), TTAMachine::Machine::Navigator< ComponentType >::count(), TTAMachine::Machine::functionUnitNavigator(), TTAMachine::FunctionUnit::hasAddressSpace(), TTAMachine::Machine::Navigator< ComponentType >::hasItem(), TTAMachine::Socket::INPUT, TTAMachine::Socket::isConnectedTo(), TTAMachine::Port::isConnectedTo(), TTAMachine::FUPort::isTriggering(), TTAMachine::Machine::Navigator< ComponentType >::item(), TTAMachine::Component::name(), TTAMachine::Port::name(), TTAMachine::FunctionUnit::operation(), TTAMachine::FunctionUnit::operationCount(), TTAMachine::FunctionUnit::operationPort(), TTAMachine::FunctionUnit::operationPortCount(), TTAMachine::Socket::OUTPUT, TTAMachine::HWOperation::pipeline(), TTAMachine::HWOperation::port(), TTAMachine::ExecutionPipeline::readOperands(), TTAMachine::Socket::setDirection(), TTAMachine::Port::socketCount(), TTAMachine::Machine::socketNavigator(), Conversion::toString(), verboseLog, VLSUConnectionBuses_, and TTAMachine::ExecutionPipeline::writtenOperands().

Referenced by explore().

Here is the call graph for this function:

copyGuards()

void ADFCombiner::copyGuards ( TTAMachine::Bus &  originalBus, TTAMachine::Bus &  addBus, const TCEString &  prefix  )

inlineprivate

Definition at line 1410 of file ADFCombiner.cc.

                                                               {
        for (int i = 0; i < originalBus.guardCount(); ++i) {
            Guard* guard = originalBus.guard(i);
            if (RegisterGuard* rg = dynamic_cast<RegisterGuard*>(guard)) {
                TCEString rfName = prefix + rg->registerFile()->name();
                int index = rg->registerIndex();
                RegisterFile* rfNew = 
                    addBus.machine()->registerFileNavigator().item(rfName);
                if (rfNew == NULL) {
                    std::cerr << "RF: " << rfName << " not found from mach!"
                              << std::endl;
                    continue;
                }
                new RegisterGuard(
                    rg->isInverted(), *rfNew, index, &addBus);
            } else if (PortGuard* pg = dynamic_cast<PortGuard*>(guard)) {
                FUPort* fuPort = pg->port();
                FunctionUnit* fu = 
                    static_cast<FunctionUnit*>(fuPort->parentUnit());
                int index = -1;
                for (int i = 0; i < fu->portCount(); i++) {
                    if (fu->port(i) == fuPort) {
                        index = i;
                    }
                }
                assert(index != -1);
                TCEString fuName = prefix + fu->name();
                FunctionUnit* fuNew = 
                    addBus.machine()->functionUnitNavigator().item(fuName);
                if (fuNew == NULL) {
                    std::cerr << "FU: " << fuName << " not found from mach!"
                        << std::endl;
                    continue;
                }
                FUPort* port = static_cast<FUPort*>(fuNew->port(index));
                new PortGuard(pg->isInverted(), *port, addBus);
            }
        }
    }

References assert, TTAMachine::Machine::functionUnitNavigator(), TTAMachine::Bus::guard(), TTAMachine::Bus::guardCount(), TTAMachine::Machine::Navigator< ComponentType >::item(), TTAMachine::Component::machine(), TTAMachine::Component::name(), TTAMachine::BaseFUPort::parentUnit(), TTAMachine::FunctionUnit::port(), TTAMachine::Unit::portCount(), and TTAMachine::Machine::registerFileNavigator().

Referenced by addGuardsToBuses().

Here is the call graph for this function:

createBus()

TTAMachine::Bus * ADFCombiner::createBus ( TTAMachine::Machine *  finalMach, TCEString  busName, int  width  )

inlineprivate

Create single bus with given name and width.

Definition at line 953 of file ADFCombiner.cc.

                   {
        TTAMachine::Bus* newBus = new TTAMachine::Bus(
            busName, width, 0,
            Machine::SIGN);
        TTAMachine::Segment* newSegment = 
            new TTAMachine::Segment(busName, *newBus);
        assert(newBus->hasSegment(newSegment->name()));
        try {     
            finalMach->addBus(*newBus);
        } catch (const ComponentAlreadyExists& e) {
            TCEString msg = 
                "ADFCombiner: Tried to add Bus with an already"
                "existing name (" + busName +")";
            throw Exception(
                __FILE__, __LINE__, __func__, msg);
        }   
        return newBus;
    }

References __func__, TTAMachine::Machine::addBus(), assert, TTAMachine::Bus::hasSegment(), TTAMachine::Segment::name(), and TTAMachine::Machine::SIGN.

Referenced by connectRegisterFiles().

Here is the call graph for this function:

createPortsAndSockets()

void ADFCombiner::createPortsAndSockets ( TTAMachine::Machine *  finalMach, TTAMachine::RegisterFile *  rf, TTAMachine::Bus *  newBus, TCEString  name, bool  readOnly, int  nodeNumber = -1  )

inlineprivate

Create new ports in RF and connected them to sockets and connect sockets to the bus.

Definition at line 978 of file ADFCombiner.cc.

                             {
        
        TTAMachine::RFPort* readPort = NULL;
        TTAMachine::RFPort* writePort = NULL;        
        TTAMachine::Socket* readSocket = NULL;
        TTAMachine::Socket* writeSocket = NULL;        
        
        if (!reuseRFPorts_) {
            // Create new ports and sockets for the register files connections
            for (int k = 0; k < rf->portCount(); k++) {
                if (rf->port(k)->name() == name + "_connect_r") {
                    readPort = rf->port(k);
                }
                if (rf->port(k)->name() == name + "_connect_w") {
                    writePort = rf->port(k);
                }                    
            }         
        } else if (reuseRFPorts_ && nodeNumber != -1) {
            // If the callee passed the node number, we connect only
            // certain ports to the bus.
            int indexRead = nodeNumber % rf->maxReads();
            int indexWrite = nodeNumber % rf->maxWrites();
            int foundReads = 0;
            int foundWrites = 0;
            for (int k = 0; k < rf->portCount(); k++) {
                if (rf->port(k)->outputSocket() != NULL) {                    
                    if (foundReads == indexRead) {
                        readPort = rf->port(k);
                        readSocket = rf->port(k)->outputSocket();
                    }
                    foundReads++;
                }
                if (rf->port(k)->inputSocket() != NULL) {                    
                    if (foundWrites == indexWrite) {
                        writePort = rf->port(k);
                        writeSocket = rf->port(k)->inputSocket();
                    }
                    foundWrites++;
                }                
            }
        } else {
            // Just find first available port for reuse.
            for (int k = 0; k < rf->portCount(); k++) {
                if (rf->port(k)->outputSocket() != NULL) {                                 
                    if (readPort == NULL) {
                        readPort = rf->port(k);
                        readSocket = rf->port(k)->outputSocket();
                    }
                }
                if (!readOnly && rf->port(k)->inputSocket() != NULL) {                    
                    if (writePort == NULL) {
                        writePort = rf->port(k);
                        writeSocket = rf->port(k)->inputSocket();
                    }
                }                
            }            
        }
 
        if (readPort == NULL) {
            readPort = new TTAMachine::RFPort(
                name + "_connect_r", *rf);
        }
        if (!readOnly && writePort == NULL) {
            writePort = new TTAMachine::RFPort(
                name + "_connect_w", *rf);        
        }
        
        const Machine::SocketNavigator socketNavigator = 
            finalMach->socketNavigator();
        
        // If we reused the ports, the socket is already known, if not 
        // try to find it or create new one.
        if (readSocket == NULL) {
            if (!socketNavigator.hasItem(readPort->name())) {
                readSocket = new TTAMachine::Socket(readPort->name());                
                try {     
                    finalMach->addSocket(*readSocket);
                } catch (const ComponentAlreadyExists& e) {
                    TCEString msg = 
                        "ADFCombiner: Tried to add Socket with "
                        " an already existing name (" + readSocket->name() +")";
                    throw Exception(
                        __FILE__, __LINE__, __func__, msg);                            
                }
            } else {
                readSocket = socketNavigator.item(readPort->name());
            }                
        }
 
        if (!readOnly && writeSocket == NULL) {
            if (!socketNavigator.hasItem(writePort->name())) {
                writeSocket = new TTAMachine::Socket(writePort->name());                
                try {     
                    finalMach->addSocket(*writeSocket);
                } catch (const ComponentAlreadyExists& e) {
                    TCEString msg = 
                    "ADFCombiner: Tried to add Socket with "
                    " an already existing name (" + writeSocket->name() +")";
                    throw Exception(
                        __FILE__, __LINE__, __func__, msg);                            
                }
            } else {
                writeSocket = socketNavigator.item(writePort->name());
            }
        }
 
        if (readPort->outputSocket() == NULL) {
            readPort->attachSocket(*readSocket);                                
        }
        if (!readSocket->isConnectedTo(*newBus->segment(0))) {
            readSocket->attachBus(*newBus->segment(0));
            readSocket->setDirection(Socket::OUTPUT);                                                    
        }
        if (!readOnly && writePort->inputSocket() == NULL) {               
            writePort->attachSocket(*writeSocket);                                                
        }
        if (!readOnly && !writeSocket->isConnectedTo(*newBus->segment(0))) {
            writeSocket->attachBus(*newBus->segment(0));                
            writeSocket->setDirection(Socket::INPUT);                                                            
        }  
    }

References __func__, TTAMachine::Machine::addSocket(), TTAMachine::Socket::attachBus(), TTAMachine::Port::attachSocket(), TTAMachine::Machine::Navigator< ComponentType >::hasItem(), TTAMachine::Socket::INPUT, TTAMachine::Port::inputSocket(), TTAMachine::Socket::isConnectedTo(), TTAMachine::Machine::Navigator< ComponentType >::item(), TTAMachine::RegisterFile::maxReads(), TTAMachine::RegisterFile::maxWrites(), DesignSpaceExplorerPlugin::name(), TTAMachine::Component::name(), TTAMachine::Port::name(), TTAMachine::Socket::OUTPUT, TTAMachine::Port::outputSocket(), TTAMachine::BaseRegisterFile::port(), TTAMachine::Unit::portCount(), reuseRFPorts_, TTAMachine::Bus::segment(), TTAMachine::Socket::setDirection(), and TTAMachine::Machine::socketNavigator().

Referenced by connectRegisterFiles().

Here is the call graph for this function:

explore()

virtual std::vector< RowID > ADFCombiner::explore ( const RowID &  , const unsigned int &    )

inlineprivatevirtual

Explorer plugin that adds machine components to a given machine with adf parameter or with configuration id in dsdb.

Reimplemented from DesignSpaceExplorerPlugin.

Definition at line 129 of file ADFCombiner.cc.

                                                 {
        readParameters();
        std::vector<RowID> result;
 
        // check if adf given
        if (extra_ == "" && node_ == "") {
            TCEString msg =
                "No node.adf or extra.adf defined. "
                "Give adfs as plugin parameters.";
            throw Exception(
                __FILE__, __LINE__, __func__, msg);
        }
 
        DSDBManager& dsdb = db();
        DSDBManager::MachineConfiguration conf;
        conf.hasImplementation = false;
        TTAMachine::Machine* nodeMach = NULL;
        TTAMachine::Machine* extraMach = NULL;
        TTAMachine::Machine* finalMach = NULL;                
 
        // load the adf from file or from dsdb
        try {
            nodeMach = TTAMachine::Machine::loadFromADF(node_);            
        } catch (const Exception& e) {
            TCEString msg =
                "Error loading the \'" + node_ + "\'";
            throw Exception(
                __FILE__, __LINE__, __func__, msg);
        }
        assert(nodeMach != NULL);
 
        if (extra_ != "") {
            try {
                extraMach = TTAMachine::Machine::loadFromADF(extra_);            
                finalMach = new TTAMachine::Machine(*extraMach);
            } catch (const Exception& e) {
                TCEString msg =
                    "Error loading the \'" + extra_ + "\'";
                throw Exception(
                    __FILE__, __LINE__, __func__, msg);
            }
        } else {
            extraMach = NULL;
            finalMach = new TTAMachine::Machine();
        }
        
        // Copies the extra machine to new architecture
        // add components
        addComponents(finalMach, nodeMach, extraMach, nodeCount_);                  
        
        // add machine to configuration
        conf.architectureID = dsdb.addArchitecture(*finalMach);
 
        // add new configuration to dsdb
        RowID confID = dsdb.addConfiguration(conf);
        
        // If requested, adds wide load/store unit
        if (vectorLSU_ && nodeCount_ > 1) {
            DesignSpaceExplorerPlugin* lsuAdd =
                DesignSpaceExplorer::loadExplorerPlugin(
                "VectorLSGenerator", &db());    
                
            lsuAdd->giveParameter("node_count", Conversion::toString(nodeCount_));            
            lsuAdd->giveParameter(
                "address_spaces", Conversion::toString(addressSpaces_));  
            lsuAdd->giveParameter(
                "add_broadcast", Conversion::toString(addBroadcast_));        
 
            lsuAdd->giveParameter(
                "shared_lsu_latency", Conversion::toString(sharedLSULatency_));
            lsuAdd->giveParameter(
                "data_lsu_latency", Conversion::toString(dataLSULatency_));
 
            std::vector<RowID> addedLSUConf = 
                lsuAdd->explore(confID);   
            
            finalMach = dsdb.architecture(addedLSUConf.back());
            
            bool connectAgain = false;
            // Connect vector units, one at a time.
            do {
                connectAgain = 
                    connectVectorLSU(finalMach, nodeMach, extraMach, nodeCount_);
            } while (connectAgain);
            
            conf.architectureID = dsdb.addArchitecture(*finalMach);
            confID = dsdb.addConfiguration(conf);       
        }
        if (buildIDF_) {
            try {
                // add idf to configuration
                selector_.selectComponentsToConf(conf, dsdb, finalMach);                
                conf.architectureID = dsdb.addArchitecture(*finalMach);
                confID = dsdb.addConfiguration(conf);                       
            } catch (const Exception& e) {
                throw Exception(
                    __FILE__, __LINE__, __func__, e.errorMessageStack());
            }
        } else {
            conf.hasImplementation = false;
        }        
        result.push_back(confID);
        return result;
    }

References __func__, DSDBManager::addArchitecture(), addBroadcast_, addComponents(), DSDBManager::addConfiguration(), addressSpaces_, DSDBManager::architecture(), DSDBManager::MachineConfiguration::architectureID, assert, buildIDF_, connectVectorLSU(), dataLSULatency_, DesignSpaceExplorer::db(), Exception::errorMessageStack(), DesignSpaceExplorerPlugin::explore(), extra_, DesignSpaceExplorerPlugin::giveParameter(), DSDBManager::MachineConfiguration::hasImplementation, DesignSpaceExplorer::loadExplorerPlugin(), TTAMachine::Machine::loadFromADF(), node_, nodeCount_, readParameters(), ComponentImplementationSelector::selectComponentsToConf(), selector_, sharedLSULatency_, Conversion::toString(), and vectorLSU_.

Here is the call graph for this function:

findGuards()

GuardSet ADFCombiner::findGuards ( TTAMachine::Machine *  mach )

inlineprivate

Definition at line 302 of file ADFCombiner.cc.

                                        {
        GuardSet guards;
        
        const TTAMachine::Machine::BusNavigator& busNav = 
            mach->busNavigator();
        
        for (int k = 0; k < busNav.count(); k++) {
            for (int j = 0; j < busNav.item(k)->guardCount(); j++) {
                guards.insert(busNav.item(k)->guard(j));
            }
        }
        return guards;
    }

References TTAMachine::Machine::busNavigator(), TTAMachine::Machine::Navigator< ComponentType >::count(), and TTAMachine::Machine::Navigator< ComponentType >::item().

Referenced by addComponents().

Here is the call graph for this function:

getExtraComponentName()

TCEString ADFCombiner::getExtraComponentName ( TCEString  originalName )

inlineprivate

Definition at line 1406 of file ADFCombiner.cc.

                                                            {
        return "EX_"  + originalName; 
    }    

Referenced by connectRegisterFiles(), and renameExtraUnits().

getNodeComponentName()

TCEString ADFCombiner::getNodeComponentName ( TCEString  originalName, int  idx  )

inlineprivate

Definition at line 1402 of file ADFCombiner.cc.

                                                                    {
        return "L_" + Conversion::toString(idx) + "_" + originalName; 
    }

References Conversion::toString().

Referenced by addBuses(), addFunctionUnits(), addRegisterFiles(), connectPorts(), and connectRegisterFiles().

Here is the call graph for this function:

nodeNamePrefix()

TCEString ADFCombiner::nodeNamePrefix ( int  nodeId )

inlineprivate

Definition at line 354 of file ADFCombiner.cc.

                                         {
       TCEString nodeNamePrefix = "L_";
       nodeNamePrefix << nodeId << "_";
       return nodeNamePrefix;     
    }

References nodeNamePrefix().

Referenced by addGuardsToBuses(), and nodeNamePrefix().

Here is the call graph for this function:

PLUGIN_DESCRIPTION()

ADFCombiner::PLUGIN_DESCRIPTION ( "Explorer plugin that produces a clustered machine with N lanes/nodes " "and an 'extras' node."  )

private

producesArchitecture()

virtual bool ADFCombiner::producesArchitecture ( ) const

inlineprivatevirtual

Implements DesignSpaceExplorerPlugin.

Definition at line 119 of file ADFCombiner.cc.

{ return true; }

readParameters()

void ADFCombiner::readParameters ( )

inlineprivate

Reads the parameters given to the plugin.

Definition at line 273 of file ADFCombiner.cc.

                          {
        readOptionalParameter(NodePN_, node_);
        readOptionalParameter(NodeCountPN_, nodeCount_);        
        readOptionalParameter(ExtraPN_, extra_);
        readOptionalParameter(BuildIDFPN_, buildIDF_);
        readOptionalParameter(VectorLSUPN_, vectorLSU_);     
        readOptionalParameter(AddressSpacesPN_, addressSpaces_);        
        readOptionalParameter(AddBroadcastPN_, addBroadcast_);
        readOptionalParameter(AddRingConnectionPN_, addRing_);             
        readOptionalParameter(AddBarConnectionPN_, addBar_);
        readOptionalParameter(AddStarConnectionPN_, addStar_);             
        readOptionalParameter(NodesPerBusPN_, nodesPerBus_);
        readOptionalParameter(ReuseRFPortsPN_, reuseRFPorts_);             
        if (vectorLSU_ && extra_ == "") {
            Application::logStream() 
                << "Warning: vector LSUs can be added only if there's an extras node."
                << std::endl;
            vectorLSU_ = false;                
        }
        readOptionalParameter(SharedLSULatencyPN_,sharedLSULatency_);
        readOptionalParameter(DataLSULatencyPN_,dataLSULatency_);
        readOptionalParameter(VLSUConnectionBusesPN_,VLSUConnectionBuses_);
    }

References addBar_, AddBarConnectionPN_, addBroadcast_, AddBroadcastPN_, addressSpaces_, AddressSpacesPN_, addRing_, AddRingConnectionPN_, addStar_, AddStarConnectionPN_, buildIDF_, BuildIDFPN_, dataLSULatency_, DataLSULatencyPN_, extra_, ExtraPN_, Application::logStream(), node_, nodeCount_, NodeCountPN_, NodePN_, nodesPerBus_, NodesPerBusPN_, DesignSpaceExplorerPlugin::readOptionalParameter(), reuseRFPorts_, ReuseRFPortsPN_, sharedLSULatency_, SharedLSULatencyPN_, vectorLSU_, VectorLSUPN_, VLSUConnectionBuses_, and VLSUConnectionBusesPN_.

Referenced by explore().

Here is the call graph for this function:

renameExtraUnits()

void ADFCombiner::renameExtraUnits ( TTAMachine::Machine *  finalMach )

inlineprivate

Definition at line 1382 of file ADFCombiner.cc.

                                                        {
        const TTAMachine::Machine::FunctionUnitNavigator& finalNav =
            finalMach->functionUnitNavigator();
        for (int i = 0; i < finalNav.count(); i++) {
            TCEString oldName = finalNav.item(i)->name();
            finalNav.item(i)->setName(getExtraComponentName(oldName));
        }
        const TTAMachine::Machine::RegisterFileNavigator& finalRFNav =
            finalMach->registerFileNavigator();
        for (int i = 0; i < finalRFNav.count(); i++) {
            TCEString oldName = finalRFNav.item(i)->name();
            finalRFNav.item(i)->setName(getExtraComponentName(oldName));
        }
        const TTAMachine::Machine::ImmediateUnitNavigator& finalImmNav =
            finalMach->immediateUnitNavigator();
        for (int i = 0; i < finalImmNav.count(); i++) {
            TCEString oldName = finalImmNav.item(i)->name();
            finalImmNav.item(i)->setName(getExtraComponentName(oldName));
        }        
    }

References TTAMachine::Machine::Navigator< ComponentType >::count(), TTAMachine::Machine::functionUnitNavigator(), getExtraComponentName(), TTAMachine::Machine::immediateUnitNavigator(), TTAMachine::Machine::Navigator< ComponentType >::item(), and TTAMachine::Machine::registerFileNavigator().

Referenced by addComponents().

Here is the call graph for this function:

requiresApplication()

virtual bool ADFCombiner::requiresApplication ( ) const

inlineprivatevirtual

Reimplemented from DesignSpaceExplorerPlugin.

Definition at line 122 of file ADFCombiner.cc.

{ return false; }

requiresHDB()

virtual bool ADFCombiner::requiresHDB ( ) const

inlineprivatevirtual

Implements DesignSpaceExplorerPlugin.

Definition at line 120 of file ADFCombiner.cc.

{ return false; }

requiresSimulationData()

virtual bool ADFCombiner::requiresSimulationData ( ) const

inlineprivatevirtual

Implements DesignSpaceExplorerPlugin.

Definition at line 121 of file ADFCombiner.cc.

{ return false; }

requiresStartingPointArchitecture()

virtual bool ADFCombiner::requiresStartingPointArchitecture ( ) const

inlineprivatevirtual

Implements DesignSpaceExplorerPlugin.

Definition at line 118 of file ADFCombiner.cc.

{ return false; }

Member Data Documentation

addBar_

bool ADFCombiner::addBar_

private

Definition at line 262 of file ADFCombiner.cc.

Referenced by ADFCombiner(), connectRegisterFiles(), and readParameters().

AddBarConnectionPN_

const TCEString ADFCombiner::AddBarConnectionPN_

staticprivate

Definition at line 246 of file ADFCombiner.cc.

Referenced by ADFCombiner(), and readParameters().

addBroadcast_

bool ADFCombiner::addBroadcast_

private

Definition at line 260 of file ADFCombiner.cc.

Referenced by ADFCombiner(), connectVectorLSU(), explore(), and readParameters().

AddBroadcastPN_

const TCEString ADFCombiner::AddBroadcastPN_

staticprivate

Definition at line 244 of file ADFCombiner.cc.

Referenced by ADFCombiner(), and readParameters().

addressSpaces_

TCEString ADFCombiner::addressSpaces_

private

Definition at line 259 of file ADFCombiner.cc.

Referenced by ADFCombiner(), explore(), and readParameters().

AddressSpacesPN_

const TCEString ADFCombiner::AddressSpacesPN_

staticprivate

Definition at line 243 of file ADFCombiner.cc.

Referenced by ADFCombiner(), and readParameters().

addRing_

bool ADFCombiner::addRing_

private

Definition at line 261 of file ADFCombiner.cc.

Referenced by ADFCombiner(), connectRegisterFiles(), and readParameters().

AddRingConnectionPN_

const TCEString ADFCombiner::AddRingConnectionPN_

staticprivate

Definition at line 245 of file ADFCombiner.cc.

Referenced by ADFCombiner(), and readParameters().

addStar_

bool ADFCombiner::addStar_

private

Definition at line 263 of file ADFCombiner.cc.

Referenced by ADFCombiner(), connectRegisterFiles(), and readParameters().

AddStarConnectionPN_

const TCEString ADFCombiner::AddStarConnectionPN_

staticprivate

Definition at line 247 of file ADFCombiner.cc.

Referenced by ADFCombiner(), and readParameters().

buildIDF_

bool ADFCombiner::buildIDF_

private

Definition at line 257 of file ADFCombiner.cc.

Referenced by ADFCombiner(), explore(), and readParameters().

BuildIDFPN_

const TCEString ADFCombiner::BuildIDFPN_

staticprivate

Definition at line 241 of file ADFCombiner.cc.

Referenced by ADFCombiner(), and readParameters().

dataLSULatency_

int ADFCombiner::dataLSULatency_

private

Definition at line 267 of file ADFCombiner.cc.

Referenced by ADFCombiner(), explore(), and readParameters().

DataLSULatencyPN_

const TCEString ADFCombiner::DataLSULatencyPN_

staticprivate

Definition at line 251 of file ADFCombiner.cc.

Referenced by ADFCombiner(), and readParameters().

extra_

TCEString ADFCombiner::extra_

private

Definition at line 256 of file ADFCombiner.cc.

Referenced by addComponents(), addFunctionUnits(), ADFCombiner(), explore(), and readParameters().

ExtraPN_

const TCEString ADFCombiner::ExtraPN_

staticprivate

Definition at line 240 of file ADFCombiner.cc.

Referenced by ADFCombiner(), and readParameters().

node_

TCEString ADFCombiner::node_

private

Definition at line 254 of file ADFCombiner.cc.

Referenced by ADFCombiner(), explore(), and readParameters().

nodeCount_

int ADFCombiner::nodeCount_

private

Definition at line 255 of file ADFCombiner.cc.

Referenced by ADFCombiner(), explore(), and readParameters().

NodeCountPN_

const TCEString ADFCombiner::NodeCountPN_

staticprivate

Definition at line 239 of file ADFCombiner.cc.

Referenced by ADFCombiner(), and readParameters().

NodePN_

const TCEString ADFCombiner::NodePN_

staticprivate

Definition at line 238 of file ADFCombiner.cc.

Referenced by ADFCombiner(), and readParameters().

nodesPerBus_

int ADFCombiner::nodesPerBus_

private

Definition at line 264 of file ADFCombiner.cc.

Referenced by ADFCombiner(), connectRegisterFiles(), and readParameters().

NodesPerBusPN_

const TCEString ADFCombiner::NodesPerBusPN_

staticprivate

Definition at line 248 of file ADFCombiner.cc.

Referenced by ADFCombiner(), and readParameters().

reuseRFPorts_

bool ADFCombiner::reuseRFPorts_

private

Definition at line 265 of file ADFCombiner.cc.

Referenced by ADFCombiner(), createPortsAndSockets(), and readParameters().

ReuseRFPortsPN_

const TCEString ADFCombiner::ReuseRFPortsPN_

staticprivate

Definition at line 249 of file ADFCombiner.cc.

Referenced by ADFCombiner(), and readParameters().

selector_

ComponentImplementationSelector ADFCombiner::selector_

private

Selector used by the plugin.

Definition at line 236 of file ADFCombiner.cc.

Referenced by explore().

sharedLSULatency_

int ADFCombiner::sharedLSULatency_

private

Definition at line 266 of file ADFCombiner.cc.

Referenced by ADFCombiner(), explore(), and readParameters().

SharedLSULatencyPN_

const TCEString ADFCombiner::SharedLSULatencyPN_

staticprivate

Definition at line 250 of file ADFCombiner.cc.

Referenced by ADFCombiner(), and readParameters().

vectorLSU_

bool ADFCombiner::vectorLSU_

private

Definition at line 258 of file ADFCombiner.cc.

Referenced by ADFCombiner(), explore(), and readParameters().

VectorLSUPN_

const TCEString ADFCombiner::VectorLSUPN_

staticprivate

Definition at line 242 of file ADFCombiner.cc.

Referenced by ADFCombiner(), and readParameters().

VLSUConnectionBuses_

int ADFCombiner::VLSUConnectionBuses_

private

Definition at line 268 of file ADFCombiner.cc.

Referenced by ADFCombiner(), connectVectorLSU(), and readParameters().

VLSUConnectionBusesPN_

const TCEString ADFCombiner::VLSUConnectionBusesPN_

staticprivate

Definition at line 252 of file ADFCombiner.cc.

Referenced by ADFCombiner(), and readParameters().

---

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

• ADFCombiner.cc