Automagic Namespace Reference

Functions
std::string	findHDBPath (std::string name)
bool	findInOptionList (const std::string &option, std::vector< std::string > list, bool enableAll=true)
std::vector< IDF::FUGenerated::DAGOperation >	generateableDAGOperations (const std::vector< IDF::FUGenerated::Info > infos, std::ostream &verbose)
std::vector< IDF::FUGenerated::Info >	createFUGeneratableOperationInfos (const ProGeOptions &options, std::ostream &verbose)
bool	checkForGeneratableFU (const ProGeOptions &options, TTAMachine::FunctionUnit &fu, IDF::FUGenerated &fug, const std::vector< IDF::FUGenerated::Info > &infos, const std::vector< IDF::FUGenerated::DAGOperation > dagops)
bool	checkForSelectableFU (const ProGeOptions &options, TTAMachine::FunctionUnit &fu, IDF::FUImplementationLocation &loc, std::ostream &verbose)
bool	checkForSelectableRF (const ProGeOptions &options, TTAMachine::RegisterFile &rf, IDF::RFImplementationLocation &loc, std::ostream &verbose)
bool	checkForSelectableIU (const ProGeOptions &options, TTAMachine::ImmediateUnit &iu, IDF::IUImplementationLocation &loc, std::ostream &verbose)
bool	canGenerateFromDAG (const OperationDAG &dag, const std::vector< IDF::FUGenerated::Info > infos, std::vector< IDF::FUGenerated::Info > *subops)
int	dagLatency (const OperationDAG &dag, const std::unordered_map< std::string, int > &maxOpLatency)
int	maxLatencyToNode (const OperationDAG &dag, OperationDAGNode &node, const std::unordered_map< std::string, int > &maxOpLatency, bool allowDifference=true)
int	nodeLatency (OperationDAGNode &node, const std::unordered_map< std::string, int > &maxOpLatency)
bool	languageMatches (HDB::BlockImplementationFile::Format format, ProGe::HDL language)

Function Documentation

canGenerateFromDAG()

bool Automagic::canGenerateFromDAG	(	const OperationDAG &	dag,
		const std::vector< IDF::FUGenerated::Info >	infos,
		std::vector< IDF::FUGenerated::Info > *	subops
	)

Checks if DAG operation can be implemented, i.e. all basic operations can be implemented

Definition at line 193 of file AutomagicTools.cc.

                                               {
    if (dag.isNull()) {
        return false;
    }
 
    bool canImplement = true;
    for (int n = 0; n < dag.nodeCount(); ++n) {
        OperationNode* operationNode =
            dynamic_cast<OperationNode*>(&dag.node(n));
        if (operationNode) {
            std::string operation = operationNode->referencedOperation().name();
            operation = StringTools::stringToLower(operation);
 
            bool foundOperation = false;
            for (auto&& info : infos) {
                if (info.operationName == operation) {
                    foundOperation = true;
                    if (subops) {
                        subops->emplace_back(info);
                    }
                    break;
                }
            }
            if (foundOperation == false) {
                canImplement = false;
                break;
            }
 
        }
    }
    return canImplement;
}

References OperationDAG::isNull(), Operation::name(), BoostGraph< GraphNode, GraphEdge >::node(), BoostGraph< GraphNode, GraphEdge >::nodeCount(), OperationNode::referencedOperation(), and StringTools::stringToLower().

Here is the call graph for this function:

checkForGeneratableFU()

bool Automagic::checkForGeneratableFU	(	const ProGeOptions &	options,
		TTAMachine::FunctionUnit &	fu,
		IDF::FUGenerated &	fug,
		const std::vector< IDF::FUGenerated::Info > &	infos,
		const std::vector< IDF::FUGenerated::DAGOperation >	dagops
	)

Check if given fu can be generated. If so return it in fug.

Definition at line 58 of file AutomagicTools.cc.

                                                        {
 
    std::vector<TTAMachine::HWOperation*> operations;
    std::vector<std::string> genops;
 
    for (int i = 0; i < fu.operationCount(); ++i) {
        operations.emplace_back(fu.operation(i));
    }
 
    for (auto&& op : operations) {
        int maxLatency;
        if (Automagic::findInOptionList(
            fug.name(), options.fuFrontRegistered, false)) {
            maxLatency = op->latency() - 1;
        } else if (Automagic::findInOptionList(
                   fug.name(), options.fuMiddleRegistered, false)) {
            maxLatency = op->latency() - 2;
        } else if (Automagic::findInOptionList(
                   fug.name(), options.fuBackRegistered, false)) {
            maxLatency = op->latency();
        } else if (Automagic::findInOptionList(
                   fug.name(), options.fuFrontRegistered)) {
            maxLatency = op->latency() - 1;
        } else if (Automagic::findInOptionList(
                   fug.name(), options.fuMiddleRegistered)) {
            maxLatency = op->latency() - 2;
        } else { // Default to back-register
            maxLatency = op->latency();
        }
        for (auto&& info : infos) {
            if (op->name() == info.operationName
                && maxLatency >= info.latency) {
                fug.addOperation(info);
                genops.emplace_back(info.operationName);
                break;
            }
        }
    }
 
    for (auto&& op : operations) {
        for (auto&& dop : dagops) {
            if (std::find(genops.begin(), genops.end(), op->name()) ==
                    genops.end() &&
                op->name() == dop.operationName) {
                fug.addOperation(dop);
                genops.emplace_back(dop.operationName);
            }
        }
    }
 
    size_t neededFUops = fu.operationCount();
 
    if (genops.size() == neededFUops) {
        return true;
    } else {
        return false;
    }
}

References IDF::FUGenerated::addOperation(), findInOptionList(), IDF::FUGenerated::name(), TTAMachine::FunctionUnit::operation(), TTAMachine::FunctionUnit::operationCount(), and options.

Here is the call graph for this function:

checkForSelectableFU()

bool Automagic::checkForSelectableFU	(	const ProGeOptions &	options,
		TTAMachine::FunctionUnit &	fu,
		IDF::FUImplementationLocation &	loc,
		std::ostream &	verbose
	)

Checks if FU has an implementation in hdbs.

Definition at line 348 of file AutomagicTools.cc.

                         {
    (void)verbose;
    for (auto&& hdb : options.hdbList) {
        std::string hdbPath = findHDBPath(hdb);
        HDB::CachedHDBManager& manager =
            HDB::CachedHDBManager::instance(hdbPath);
        std::set<RowID> rows = manager.fuEntryIDs();
        for (auto&& row : rows) {
            auto fuEntry = manager.fuByEntryID(row);
            if (!fuEntry->hasImplementation() ||
                !fuEntry->hasArchitecture()) {
                continue;
            }
            auto arch = fuEntry->architecture();
            auto impl = fuEntry->implementation();
            // Check that operations match.
            if (fu.operationCount() !=
                arch.architecture().operationCount()) {
                continue;
            }
            bool wrongLanguage = false;
            for (int i = 0; i < impl.implementationFileCount(); ++i) {
                auto f = impl.file(i);
                if (f.format() ==
                        HDB::BlockImplementationFile::Format::VHDL &&
                    options.language == ProGe::HDL::Verilog) {
                    wrongLanguage = true;
                    break;
                } else if (f.format() == HDB::BlockImplementationFile::
                                             Format::Verilog &&
                           options.language == ProGe::HDL::VHDL) {
                    wrongLanguage = true;
                    break;
                }
            }
            if (wrongLanguage) {
                continue;
            }
            bool found = true;
            for (int i = 0; i < fu.operationCount(); ++i) {
                auto op = fu.operation(i);
                if (!arch.architecture().hasOperation(op->name())) {
                    found = false;
                    break;
                }
                if (op->latency() !=
                    arch.architecture().operation(op->name())->latency()) {
                    found = false;
                    break;
                }
            }
            if (!found) {
                continue;
            }
 
            loc.setID(row);
            loc.setHDBFile(hdbPath);
            return true;
        }
    }
 
    return false;
}

References HDB::FUEntry::architecture(), HDB::HDBManager::fuByEntryID(), HDB::HDBManager::fuEntryIDs(), HDB::CachedHDBManager::instance(), TTAMachine::FunctionUnit::operation(), TTAMachine::FunctionUnit::operationCount(), options, IDF::UnitImplementationLocation::setHDBFile(), IDF::UnitImplementationLocation::setID(), ProGe::Verilog, HDB::BlockImplementationFile::VHDL, and ProGe::VHDL.

Here is the call graph for this function:

checkForSelectableIU()

bool Automagic::checkForSelectableIU	(	const ProGeOptions &	options,
		TTAMachine::ImmediateUnit &	iu,
		IDF::IUImplementationLocation &	loc,
		std::ostream &	verbose
	)

Checks if RF has an implementation in hdbs.

Definition at line 491 of file AutomagicTools.cc.

                         {
    (void)verbose;
    for (auto&& hdb : options.hdbList) {
        std::string hdbPath = findHDBPath(hdb);
        HDB::CachedHDBManager& manager =
            HDB::CachedHDBManager::instance(hdbPath);
        std::set<RowID> rows = manager.rfEntryIDs();
        for (auto&& row : rows) {
            auto rfEntry = manager.rfByEntryID(row);
            // Exclude these:
            if (!rfEntry->hasImplementation() ||
                !rfEntry->hasArchitecture()) {
                continue;
            }
            auto arch = rfEntry->architecture();
            auto impl = rfEntry->implementation();
            bool wrongLanguage = false;
            for (int i = 0; i < impl.implementationFileCount(); ++i) {
                auto f = impl.file(i);
                if (f.format() ==
                        HDB::BlockImplementationFile::Format::VHDL &&
                    options.language == ProGe::HDL::Verilog) {
                    wrongLanguage = true;
                    break;
                } else if (f.format() == HDB::BlockImplementationFile::
                                             Format::Verilog &&
                           options.language == ProGe::HDL::VHDL) {
                    wrongLanguage = true;
                    break;
                }
            }
            if (wrongLanguage) {
                continue;
            }
            if (iu.isUsedAsGuard() != arch.hasGuardSupport()) {
                continue;
            }
            if (iu.maxReads() != arch.readPortCount()) {
                continue;
            }
            if (1 != arch.writePortCount()) {
                continue;
            }
            if (iu.latency() != arch.latency()) {
                continue;
            }
            if (!arch.hasParameterizedWidth() &&
                (iu.width() != arch.width())) {
                continue;
            }
            if (!arch.hasParameterizedSize() &&
                (iu.size() != arch.size())) {
                continue;
            }
            // Must be a perfect choise.
            loc.setID(row);
            loc.setHDBFile(hdbPath);
            return true;
        }
    }
    return false;
}

References HDB::RFEntry::architecture(), HDB::CachedHDBManager::instance(), TTAMachine::RegisterFile::isUsedAsGuard(), TTAMachine::ImmediateUnit::latency(), TTAMachine::RegisterFile::maxReads(), options, HDB::HDBManager::rfByEntryID(), HDB::HDBManager::rfEntryIDs(), IDF::UnitImplementationLocation::setHDBFile(), IDF::UnitImplementationLocation::setID(), TTAMachine::BaseRegisterFile::size(), ProGe::Verilog, HDB::BlockImplementationFile::VHDL, ProGe::VHDL, and TTAMachine::BaseRegisterFile::width().

Here is the call graph for this function:

checkForSelectableRF()

bool Automagic::checkForSelectableRF	(	const ProGeOptions &	options,
		TTAMachine::RegisterFile &	rf,
		IDF::RFImplementationLocation &	loc,
		std::ostream &	verbose
	)

Checks if RF has an implementation in hdbs.

Definition at line 417 of file AutomagicTools.cc.

                         {
    (void)verbose;
    for (auto&& hdb : options.hdbList) {
        std::string hdbPath = findHDBPath(hdb);
        HDB::CachedHDBManager& manager =
            HDB::CachedHDBManager::instance(hdbPath);
        std::set<RowID> rows = manager.rfEntryIDs();
        for (auto&& row : rows) {
            auto rfEntry = manager.rfByEntryID(row);
            // Exclude these:
            if (!rfEntry->hasImplementation() ||
                !rfEntry->hasArchitecture()) {
                continue;
            }
            auto arch = rfEntry->architecture();
            auto impl = rfEntry->implementation();
            bool wrongLanguage = false;
            for (int i = 0; i < impl.implementationFileCount(); ++i) {
                auto f = impl.file(i);
                if (f.format() ==
                        HDB::BlockImplementationFile::Format::VHDL &&
                    options.language == ProGe::HDL::Verilog) {
                    wrongLanguage = true;
                    break;
                } else if (f.format() == HDB::BlockImplementationFile::
                                             Format::Verilog &&
                           options.language == ProGe::HDL::VHDL) {
                    wrongLanguage = true;
                    break;
                }
            }
            if (wrongLanguage) {
                continue;
            }
            if (rf.isUsedAsGuard() != arch.hasGuardSupport()) {
                continue;
            }
            if (rf.outputPortCount() != arch.readPortCount()) {
                continue;
            }
            if (rf.inputPortCount() != arch.writePortCount()) {
                continue;
            }
            if (rf.bidirPortCount() != arch.bidirPortCount()) {
                continue;
            }
            if (1 != arch.latency()) {
                continue;
            }
            if (rf.guardLatency() != arch.guardLatency()) {
                continue;
            }
            if (!arch.hasParameterizedWidth() &&
                (rf.width() != arch.width())) {
                continue;
            }
            if (!arch.hasParameterizedSize() &&
                (rf.size() != arch.size())) {
                continue;
            }
            // Must be a perfect choise.
            loc.setID(row);
            loc.setHDBFile(hdbPath);
            return true;
        }
    }
    return false;
}

References HDB::RFEntry::architecture(), TTAMachine::Unit::bidirPortCount(), TTAMachine::RegisterFile::guardLatency(), TTAMachine::Unit::inputPortCount(), HDB::CachedHDBManager::instance(), TTAMachine::RegisterFile::isUsedAsGuard(), options, TTAMachine::Unit::outputPortCount(), HDB::HDBManager::rfByEntryID(), HDB::HDBManager::rfEntryIDs(), IDF::UnitImplementationLocation::setHDBFile(), IDF::UnitImplementationLocation::setID(), TTAMachine::BaseRegisterFile::size(), ProGe::Verilog, HDB::BlockImplementationFile::VHDL, ProGe::VHDL, and TTAMachine::BaseRegisterFile::width().

Here is the call graph for this function:

createFUGeneratableOperationInfos()

std::vector< IDF::FUGenerated::Info > Automagic::createFUGeneratableOperationInfos	(	const ProGeOptions &	options,
		std::ostream &	verbose
	)

Parses all given hdbs for operation implementations.

Definition at line 305 of file AutomagicTools.cc.

                                                      {
    std::vector<IDF::FUGenerated::Info> infos;
 
    for (auto&& hdb : options.hdbList) {
        std::string hdbPath = findHDBPath(hdb);
        verbose << " searching implementations from " << hdbPath << "\n";
        HDB::CachedHDBManager& manager =
            HDB::CachedHDBManager::instance(hdbPath);
        std::set<RowID> rows = manager.OperationImplementationIDs();
        std::vector<IDF::FUGenerated::Info> newInfos;
        for (auto&& row : rows) {
            auto opimpl = manager.OperationImplementationByID(row);
            newInfos.emplace_back(IDF::FUGenerated::Info{opimpl.name, hdbPath,
                                                opimpl.id, opimpl.latency});
        }
 
        std::sort(newInfos.begin(), newInfos.end(),
                  [](IDF::FUGenerated::Info a, IDF::FUGenerated::Info b)
                  { return a.latency > b.latency; });
 
        infos.insert(infos.end(), newInfos.begin(), newInfos.end());
    }
 
    return infos;
}

References IDF::FUGenerated::Info::id, HDB::CachedHDBManager::instance(), HDB::HDBManager::OperationImplementationByID(), HDB::HDBManager::OperationImplementationIDs(), and options.

Here is the call graph for this function:

dagLatency()

int Automagic::dagLatency	(	const OperationDAG &	dag,
		const std::unordered_map< std::string, int > &	maxOpLatency
	)

Finds the maximum latency of the dag. Uses maxOpLatency for the node latencies.

Definition at line 233 of file AutomagicTools.cc.

                                                              {
    assert(!dag.isNull());
 
    int maxLatency = 0;
 
    // To find the global critical path, go through every end terminal's
    // critical path and find the maximum.
    auto sinkNodes = dag.sinkNodes();
    for (auto node : sinkNodes) {
        int latency = maxLatencyToNode(dag, *node, maxOpLatency);
        maxLatency = std::max(latency, maxLatency);
    }
    return maxLatency;
}

References assert, OperationDAG::isNull(), and BoostGraph< GraphNode, GraphEdge >::sinkNodes().

Here is the call graph for this function:

findHDBPath()

std::string Automagic::findHDBPath

(

std::string

name

)

Tries to find full path for hdb file.

Definition at line 335 of file AutomagicTools.cc.

                                               {
 
    if (FileSystem::fileExists(name)) {
        return name;
    }
 
    std::vector<std::string> paths = Environment::hdbPaths();
    return FileSystem::findFileInSearchPaths(paths, name);
}

References FileSystem::fileExists(), FileSystem::findFileInSearchPaths(), and Environment::hdbPaths().

Here is the call graph for this function:

findInOptionList()

bool Automagic::findInOptionList	(	const std::string &	option,
		std::vector< std::string >	list,
		bool	enableAll = true
	)

Check if option is in the list or list has 'ALL' in it.

Definition at line 123 of file AutomagicTools.cc.

                                                                        {
    std::string lowered_option = StringTools::stringToLower(option);
    for (auto&& item : list) {
        std::string lowered_item = StringTools::stringToLower(item);
        if (lowered_item == lowered_option
            || (enableAll && lowered_item == "all")) {
            return true;
        }
    }
    return false;
}

References StringTools::stringToLower().

Referenced by checkForGeneratableFU().

Here is the call graph for this function:

generateableDAGOperations()

std::vector< IDF::FUGenerated::DAGOperation > Automagic::generateableDAGOperations	(	const std::vector< IDF::FUGenerated::Info >	infos,
		std::ostream &	verbose
	)

Find out all operations we can generate from DAG.

Definition at line 140 of file AutomagicTools.cc.

                         {
    std::vector<IDF::FUGenerated::DAGOperation> dagops;
    std::set<std::string> opNames;
 
    verbose << " can implement DAG operations that use:\n  ";
    std::string sep;
    for (auto&& info : infos) {
        verbose << sep << info.operationName;
        sep = ", ";
    }
    verbose << "\n";
 
    OperationPool opPool;
    OperationIndex& opIndex = opPool.index();
    for (int i = 0; i < opIndex.moduleCount(); ++i) {
        OperationModule& module = opIndex.module(i);
        for (int j = 0; j < opIndex.operationCount(module); ++j) {
            std::string opName = opIndex.operationName(j, module);
            if (opNames.count(opName) > 0) {
                continue;
            }
            Operation& op = opPool.operation(opName.c_str());
            for (int d = 0; d < op.dagCount(); ++d) {
                std::vector<IDF::FUGenerated::Info> subops;
                if (canGenerateFromDAG(op.dag(d), infos, &subops)) {
                    opName = StringTools::stringToLower(opName);
                    dagops.emplace_back(IDF::FUGenerated::DAGOperation{opName,
                                                                       subops});
                    opNames.insert(opName);
                    break;
                }
            }
        }
    }
 
    verbose << " can implement DAG operations:\n  ";
    sep = "";
    for (auto&& op : dagops) {
        verbose << sep << op.operationName;
        sep = ", ";
    }
    verbose << "\n";
 
    return dagops;
}

References Operation::dag(), Operation::dagCount(), OperationPool::index(), OperationIndex::moduleCount(), OperationPool::operation(), OperationIndex::operationCount(), OperationIndex::operationName(), and StringTools::stringToLower().

Here is the call graph for this function:

languageMatches()

bool Automagic::languageMatches	(	HDB::BlockImplementationFile::Format	format,
		ProGe::HDL	language
	)

maxLatencyToNode()

int Automagic::maxLatencyToNode	(	const OperationDAG &	dag,
		OperationDAGNode &	node,
		const std::unordered_map< std::string, int > &	maxOpLatency,
		bool	allowDifference = true
	)

Definition at line 273 of file AutomagicTools.cc.

                          {
 
    // Go through all the parents.
    int maxLeafLatency = -1;
    for (auto&& e : dag.inEdges(node)) {
        OperationDAGNode& nextNode = dag.tailNode(*e);
        // Recursive call to parent nodes
        int parentLatency =  maxLatencyToNode(dag, nextNode, maxOpLatency)
                           + nodeLatency(nextNode, maxOpLatency);
 
        if (!allowDifference && maxLeafLatency != -1) {
            assert(maxLeafLatency == parentLatency &&
                   "Two input edges of DAG node have different latency!");
        }
 
        maxLeafLatency = std::max(maxLeafLatency, parentLatency);
    }
 
    // For nodes without children
    maxLeafLatency = std::max(maxLeafLatency, 0);
 
    // Return only the longest leaf latency.
    return maxLeafLatency;
}

References assert, BoostGraph< GraphNode, GraphEdge >::inEdges(), and BoostGraph< GraphNode, GraphEdge >::tailNode().

Here is the call graph for this function:

nodeLatency()

int Automagic::nodeLatency	(	OperationDAGNode &	node,
		const std::unordered_map< std::string, int > &	maxOpLatency
	)

Definition at line 250 of file AutomagicTools.cc.

                                                          {
 
    int latency = 0;
 
    OperationNode* operationNode = dynamic_cast<OperationNode*>(&node);
    if (operationNode) {
        std::string subOpName = operationNode->referencedOperation().name();
        subOpName = StringTools::stringToLower(subOpName);
        if (maxOpLatency.find(subOpName) != maxOpLatency.end()) {
            latency = maxOpLatency.at(subOpName);
        }
    }
 
    return latency;
}

References Operation::name(), OperationNode::referencedOperation(), and StringTools::stringToLower().

Here is the call graph for this function: