PerfEngine.cpp

Go to the documentation of this file.

/*******************************************************************************
 * The software programs comprising "CGRA-ME" and the documentation provided
 * with them are copyright by its authors and the University of Toronto. Only
 * non-commercial, not-for-profit use of this software is permitted without ex-
 * plicit permission. This software is provided "as is" with no warranties or
 * guarantees of support. See the LICENCE for more details. You should have re-
 * ceived a copy of the full licence along with this software. If not, see
 * <http://cgra-me.ece.utoronto.ca/license/>.
 ******************************************************************************/
 
#include <CGRA/PerfEngine.h>
 
PerfEngine::PerfEngine(std::string ini_path)
{
    // Parse INI for each performance modelling, ignored if INI DNE
    std::ifstream area_ini(ini_path + "/area.ini");
    if(area_ini)
    {
        cgrame_msg(ini_path + "area.ini found.");
        std::string area_ini_str(
            (std::istreambuf_iterator<char>(area_ini)),
            std::istreambuf_iterator<char>()
            );
        _parseAreaINI(area_ini_str);
    }
    else
    {
        cgrame_warn(ini_path + "area.ini not found. Skipping...");
    }
 
    std::ifstream timing_ini(ini_path + "/timing.ini");
    if(timing_ini)
    {
        cgrame_msg(ini_path + "timing.ini found.");
        std::string timing_ini_str(
            (std::istreambuf_iterator<char>(timing_ini)),
            std::istreambuf_iterator<char>()
            );
        _parseTimingINI(timing_ini_str);
    }
    else
    {
        cgrame_warn(ini_path + "timing.ini not found. Skipping...");
    }
 
    std::ifstream power_ini(ini_path + "/power.ini");
    if(power_ini)
    {
        cgrame_msg(ini_path + "power.ini found.");
        std::string power_ini_str(
            (std::istreambuf_iterator<char>(power_ini)),
            std::istreambuf_iterator<char>()
            );
        _parsePowerINI(power_ini_str);
    }
    else
    {
        cgrame_warn(ini_path + "power.ini not found. Skipping...");
    }
}
 
PerfEngine::~PerfEngine()
{
}
 
double PerfEngine::_setModuleArea(Module* m, unsigned int level, bool last)
{
    m->hierarchyLevel = level;
    m->isLastInHierarchy = last;
    std::string module_name = m->GenericName();
    double module_area = 0.0;
 
    std::string delim = "_";
    size_t index = module_name.find(delim);
    std::string module_basename = module_name.substr(0, index);
    std::string module_suffix = module_name.substr(index + 1, module_name.length());
    std::string model_key = module_basename + "." + module_suffix;
 
    if (module_basename == "func")
    {
        // check whether it is already calculated
        if (areaModels.count(model_key) != 0)
        {
            cgrame_msg("Area model of \"" + model_key + "\" found.");
            m->area = areaModels[model_key];
            m->submodsSet = false;
            return areaModels[model_key];
        }
 
        // return calculated func unit area
        size_t start = 5;
        size_t end = 0;
        std::vector<std::string> ops;
        do
        {
            end = module_name.find(delim, start);
            std::string op = module_name.substr(start, end - start);
            start = end + 1;
            ops.push_back(op);
        } while (end != std::string::npos);
        std::string bus_width = ops[0];
        for (int i = 1; i < ops.size(); i++)
        {
            std::string k = "op." + ops[i] + "_" + bus_width;
            if (areaModels.count(k) == 0)
                throw cgrame_error("Area model of \"" + k + "\" does not exist...");
            cgrame_msg("Area model of \"" + k + "\" found.");
            module_area += areaModels[k];
        }
 
        // add entry to opt out re-calculation
        cgrame_msg("Area model of \"" + model_key + "\" generated.");
        areaModels[model_key] = module_area;
        m->area = module_area;
        m->submodsSet = false;
        return module_area;
    }
    else
    {
        bool determined = false;
        if (areaModels.count(model_key) != 0)
        {
            determined = true;
            module_area = areaModels[model_key];
            cgrame_msg("Area model of \"" + model_key + "\" found.");
            m->area = module_area;
            m->submodsSet = false;
            return module_area;
        }
        else if (m->submodules.size() == 0) // a module without submodule must have an area entry
            throw cgrame_error("Area model of \"" + model_key + "\" does not exist...");
 
        unsigned int i = 0;
        unsigned int i_last = m->submodules.size() - 1;
        for (const auto& sm : m->submodules)
        {
            std::string inst_name = sm.first;
            Module* submodule = sm.second;
            module_area += _setModuleArea(submodule, level + 1, i == i_last);
            i++;
        }
 
        // add entry to opt out re-calculation
        cgrame_msg("Area model of \"" + model_key + "\" generated.");
        areaModels[model_key] = module_area;
        m->area = module_area;
        m->submodsSet = true;
        return module_area;
    }
}
 
void PerfEngine::reportArea(std::shared_ptr<CGRA> target)
{
    cgrame_msg("Populating hierarchical module area.");
    double total_area = _setModuleArea(&(target->getTopLevelModule()), 0, true);
 
    // Redirect output buffer
    std::string filename = "/tmp/CGRAME_AreaReport.rpt";
    std::streambuf* original_sbuf = std::cout.rdbuf();
    std::ofstream rpt_filebuf(filename);
    std::cout.rdbuf(rpt_filebuf.rdbuf()); // Redirects to new file
 
    reportLevelOrderArea(&(target->getTopLevelModule()));
 
    // Restore output buffer
    std::cout.rdbuf(original_sbuf);
    cgrame_msg("Area estimation completed. Report dumped to: `/tmp/CGRAME_AreaReport.rpt`");
}
 
void PerfEngine::reportLevelOrderArea(Module* m)
{
    auto area = m->area;
    auto level = m->hierarchyLevel;
    auto last = m->isLastInHierarchy;
    std::string treeDrawing;
    auto n = m;
    if (n->hierarchyLevel != 0)
        treeDrawing = (n->isLastInHierarchy)?" └─ ":" ├─ ";
    if (n->parent != NULL)
    {
        do
        {
            n = n->parent;
            if (n->hierarchyLevel == 0)
                break;
            if (n->isLastInHierarchy)
                treeDrawing = "    " + treeDrawing;
            else
                treeDrawing = " │  " + treeDrawing;
        } while(n->hierarchyLevel > 0);
    }
    std::cout << treeDrawing;
    std::cout << m->getName();
    std::cout << "(" << m->GenericName() << ") : " << std::to_string(area) << std::endl;
    if (!m->submodsSet) // submodule should be skipped if they were opt-ed out
        return;
    for (const auto& sm : m->submodules)
    {
        auto submodule = sm.second;
        reportLevelOrderArea(submodule);
    }
}
 
// Return a multimap representing the mapped MRRG, with sources as keys, destination as values
EdgeList PerfEngine::_genMappedMRRG(const OpGraph& og, std::map<const OpGraphNode*,std::vector<MRRG::NodeDescriptor>>& m)
{
    EdgeList res;
    std::vector<MRRG::NodeDescriptor> fu_nodes;
 
    // Populate fu_nodes with intermediate MRRGNodes connecting
    for(auto & op : og.opNodes())
    {
        MRRG::NodeDescriptor n = m.at(op).front();
        //n->mapped_opcode = op->opcode;
        mapped_node2opcode[n] = op->opcode;
        fu_nodes.push_back(n);
    }
 
    // Populate res with partial MRRGs
    for(auto & val : og.valNodes())
    {
        EdgeList partial;
 
        for(auto & node_a : m.at(val))
        {
            for(auto & node_b : m.at(val))
            {
                if (node_a == node_b) continue;
 
                // confirm relation to node_a
                auto fanout = node_a->fanout;
                if (std::find(fanout.begin(), fanout.end(), node_b) != fanout.end())
                {
                    // node_a -> node_b (`a` drives `b`)
                    res.insert(std::pair<MRRG::NodeDescriptor, MRRG::NodeDescriptor> (node_a, node_b));
                    partial.insert(std::pair<MRRG::NodeDescriptor, MRRG::NodeDescriptor> (node_a, node_b));
                }
            }
        }
 
        /*
        // Dump MRRG dot of this op
        std::cout << "digraph " << *val << " {" << std::endl;
        for(auto & node : m.at(val))
        {
            std::cout << "\"" << *node << "\";" << std::endl;
        }
        for(auto it = partial.begin(); it != partial.end(); it = partial.upper_bound(it->first))
        {
            auto i = it;
            while (i != partial.upper_bound(it->first))
            {
                auto src = i->first;
                auto des = i->second;
                std::cout << "\"" << *src << "\" -> \"" << *des << "\";" << std::endl;
                i++;
            }
        }
        std::cout << "}\n" << std::endl;
        */
    }
 
    std::vector<MRRG::NodeDescriptor> src_list;
    for(auto it = res.begin(); it != res.end(); it = res.upper_bound(it->first))
        if (std::find(src_list.begin(), src_list.end(), it->first) == src_list.end())
            src_list.push_back(it->first);
 
    // Resolve disconnection in res using fu_nodes
    for(auto i = 0; i < fu_nodes.size(); i++)
    {
        // connect FU MRRG nodes to inputs of partial MRRGs
        for(auto it_i = res.begin(); it_i != res.end(); it_i = res.upper_bound(it_i->first))
        {
            auto node = it_i->first;
 
            // skip if it is a FU MRRG node
            if (std::find(fu_nodes.begin(), fu_nodes.end(), node) != fu_nodes.end()) continue;
 
            bool has_no_src = true;
            for(auto it_j = res.begin(); it_j != res.end(); it_j++)
            {
                auto des = it_j->second;
                if (node == des)
                {
                    has_no_src = false;
                    break;
                }
            }
 
            if (has_no_src)
            {
                // add appropriate edge if it exist: FU MRRG node -> MRRG node with no source
                for(auto & fu_node : fu_nodes)
                {
                    auto pos = std::find(src_list.begin(), src_list.end(), node);
                    if (std::find(node->fanin.begin(), node->fanin.end(), fu_node) != node->fanin.end())
                    {
                        res.insert(std::pair<MRRG::NodeDescriptor, MRRG::NodeDescriptor> (fu_node, node));
                        if (pos != src_list.end())
                            src_list.erase(pos);
                    }
                }
            }
        }
 
        // connect outputs of partial MRRGs to FU MRRG nodes
        for(auto it = res.begin(); it != res.end(); it++)
        {
            auto node = it->second;
 
            // skip if it is a FU MRRG node
            if (std::find(fu_nodes.begin(), fu_nodes.end(), node) != fu_nodes.end()) continue;
 
            bool has_no_des = (std::find(src_list.begin(), src_list.end(), node) == src_list.end());
            if (has_no_des)
            {
                // add appropriate edge if it exist: MRRG node with no destination -> FU MRRG node
                for(auto & fu_node : fu_nodes)
                {
                    if (std::find(node->fanout.begin(), node->fanout.end(), fu_node) != node->fanout.end())
                    {
                        res.insert(std::pair<MRRG::NodeDescriptor, MRRG::NodeDescriptor> (node, fu_node));
                        src_list.push_back(node);
                    }
                }
            }
        }
    }
 
    /*
    */
    // Dump MRRG dot of mapped result
    std::cout << "digraph MappedMRRG {" << std::endl;
    for(auto & op : og.opNodes())
    {
        std::cout << "\"" << *m.at(op).front() << "\";" << std::endl;
    }
    for(auto & val : og.valNodes())
    {
        for(auto & node : m.at(val))
        {
            std::cout << "\"" << *node << "\";" << std::endl;
        }
    }
    for(auto it = res.begin(); it != res.end(); it = res.upper_bound(it->first))
    {
        auto i = it;
        while (i != res.upper_bound(it->first))
        {
            auto src = i->first;
            auto des = i->second;
            std::cout << "\"" << *src << "\" -> \"" << *des << "\";" << std::endl;
            i++;
        }
    }
    std::cout << "}\n" << std::endl;
    /*
    */
 
    return res;
}
 
void PerfEngine::reportTiming(std::shared_ptr<CGRA> target, const Mapping& map_res)
{
    // Reconstruct MRRG graph of mapped nodes only
    auto& opgraph = map_res.getOpGraph();
    auto mapping = map_res.getMapping();
    auto mapped_mrrg = _genMappedMRRG(opgraph, mapping);
 
    // Construct Tatum structures with delays from profile (tg, tc, dc, ta)
    std::shared_ptr<TatumInterface> sta_interface(new TatumInterface(timingModels, this));
    sta_interface->createTatumTimingGraph(mapped_mrrg);
 
    // Initialize the Tatum STA engine
    sta_interface->initializeTatumEngine(mapped_mrrg);
 
    // Update user-specified wire delays
    //TODO: implement
 
    // Tatum report
    sta_interface->reportSetupAnalysis();
}
 
void PerfEngine::reportPower(std::shared_ptr<CGRA> target)
{
}
 
void PerfEngine::_parseAreaINI(std::string file_str)
{
    mINI area_ini;
    if (area_ini.parse(file_str))
    {
        for (const auto& entry : area_ini)
        {
            std::string key = entry.first;
            double val = stod(entry.second);
            areaModels[key] = val;
        }
    }
    else
    {
        throw cgrame_error("Error parsing area.ini. Please verify syntax");
    }
 
    // Print the read area profile
    //for (std::map<std::string, double>::iterator i = areaModels.begin(); i != areaModels.end(); ++i)
    //{
    //    std::string k = i->first;
    //    cgrame_msg("areaModels["+k+"] gets "+std::to_string(areaModels[k]));
    //}
}
 
void PerfEngine::_parseTimingINI(std::string file_str)
{
    mINI timing_ini;
    if (timing_ini.parse(file_str))
    {
        for (const auto& entry : timing_ini)
        {
            std::string key = entry.first;
            double val = stod(entry.second);
            timingModels[key] = val;
        }
    }
    else
    {
        throw cgrame_error("Error parsing timing.ini. Please verify syntax");
    }
 
    // Print the read timing profile
    //for (std::map<std::string, double>::iterator i = timingModels.begin(); i != timingModels.end(); ++i)
    //{
    //    std::string k = i->first;
    //    std::ostringstream valStream;
    //    valStream << std::scientific << std::setprecision(3) << timingModels[k];
    //    std::string valStr = valStream.str();
    //    cgrame_msg("timingModels["+k+"] gets " + valStr);
    //}
}
 
void PerfEngine::_parsePowerINI(std::string file_str)
{
}