ProGeTools 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 ProGeTools::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 194 of file ProGeTools.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().

Referenced by Automagic::generateableDAGOperations(), generateableDAGOperations(), and FUGen::parseOperations().

Here is the call graph for this function:

checkForGeneratableFU()

bool ProGeTools::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 59 of file ProGeTools.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 (ProGeTools::findInOptionList(
                fug.name(), options.fuFrontRegistered, false)) {
            maxLatency = op->latency() - 1;
        } else if (ProGeTools::findInOptionList(
                       fug.name(), options.fuMiddleRegistered, false)) {
            maxLatency = op->latency() - 2;
        } else if (ProGeTools::findInOptionList(
                       fug.name(), options.fuBackRegistered, false)) {
            maxLatency = op->latency();
        } else if (ProGeTools::findInOptionList(
                       fug.name(), options.fuFrontRegistered)) {
            maxLatency = op->latency() - 1;
        } else if (ProGeTools::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.

Referenced by ProGe::ProGeUI::generateIDF().

Here is the call graph for this function:

checkForSelectableFU()

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

Checks if FU has an implementation in hdbs.

Definition at line 352 of file ProGeTools.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(), findHDBPath(), HDB::HDBManager::fuByEntryID(), HDB::HDBManager::fuEntryIDs(), HDB::CachedHDBManager::instance(), TTAMachine::FunctionUnit::operation(), TTAMachine::FunctionUnit::operationCount(), options, IDF::UnitImplementationLocation::setHDBFile(), IDF::UnitImplementationLocation::setID(), ProGe::Verilog, and ProGe::VHDL.

Referenced by ProGe::ProGeUI::generateIDF().

Here is the call graph for this function:

checkForSelectableIU()

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

Checks if RF has an implementation in hdbs.

Definition at line 500 of file ProGeTools.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(), findHDBPath(), 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, ProGe::VHDL, and TTAMachine::BaseRegisterFile::width().

Referenced by ProGe::ProGeUI::generateIDF().

Here is the call graph for this function:

checkForSelectableRF()

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

Checks if RF has an implementation in hdbs.

Definition at line 422 of file ProGeTools.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;
            }
            if (rf.zeroRegister() != arch.zeroRegister()) {
                continue;
            }
            // Must be a perfect choise.
            loc.setID(row);
            loc.setHDBFile(hdbPath);
            return true;
        }
    }
    return false;
}

References HDB::RFEntry::architecture(), TTAMachine::Unit::bidirPortCount(), findHDBPath(), 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, ProGe::VHDL, TTAMachine::BaseRegisterFile::width(), and TTAMachine::RegisterFile::zeroRegister().

Referenced by ProGe::ProGeUI::generateIDF().

Here is the call graph for this function:

createFUGeneratableOperationInfos()

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

Parses all given hdbs for operation implementations.

Definition at line 306 of file ProGeTools.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 findHDBPath(), IDF::FUGenerated::Info::id, HDB::CachedHDBManager::instance(), HDB::HDBManager::OperationImplementationByID(), HDB::HDBManager::OperationImplementationIDs(), and options.

Referenced by ProGe::ProGeUI::generateIDF().

Here is the call graph for this function:

dagLatency()

int ProGeTools::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 234 of file ProGeTools.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(), maxLatencyToNode(), and BoostGraph< GraphNode, GraphEdge >::sinkNodes().

Referenced by FUGen::parseOperations().

Here is the call graph for this function:

findHDBPath()

std::string ProGeTools::findHDBPath

(

std::string

name

)

Tries to find full path for hdb file.

Definition at line 339 of file ProGeTools.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().

Referenced by Automagic::checkForSelectableFU(), checkForSelectableFU(), Automagic::checkForSelectableIU(), checkForSelectableIU(), checkForSelectableRF(), Automagic::checkForSelectableRF(), Automagic::createFUGeneratableOperationInfos(), and createFUGeneratableOperationInfos().

Here is the call graph for this function:

findInOptionList()

bool ProGeTools::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 124 of file ProGeTools.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(), FUGen::createMandatoryPorts(), FUGen::createShadowRegisters(), and FUGen::implement().

Here is the call graph for this function:

generateableDAGOperations()

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

Find out all operations we can generate from DAG.

Definition at line 142 of file ProGeTools.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 canGenerateFromDAG(), Operation::dag(), Operation::dagCount(), OperationPool::index(), OperationIndex::module(), OperationIndex::moduleCount(), OperationPool::operation(), OperationIndex::operationCount(), OperationIndex::operationName(), and StringTools::stringToLower().

Referenced by ProGe::ProGeUI::generateIDF().

Here is the call graph for this function:

languageMatches()

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

maxLatencyToNode()

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

Definition at line 274 of file ProGeTools.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(), nodeLatency(), and BoostGraph< GraphNode, GraphEdge >::tailNode().

Referenced by Automagic::dagLatency(), dagLatency(), Automagic::maxLatencyToNode(), and FUGen::scheduleOperations().

Here is the call graph for this function:

nodeLatency()

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

Definition at line 252 of file ProGeTools.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().

Referenced by Automagic::maxLatencyToNode(), and maxLatencyToNode().

Here is the call graph for this function: