Visual.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/Exception.h>
#include <CGRA/Visual.h>
#include <CGRA/Module.h>
 
#include <string>
#include <set>
#include <regex>
#include <unordered_set>
#include <functional>
#include <iostream>
#include <fstream>
#include <sstream>
 
#include <sys/stat.h>
#include <sys/types.h>
 
#define NO_PREVIOUS_CYCLE_INPUT
 
void genCGRAVisual(std::string exe_path, std::shared_ptr<CGRA> cgra, int II)
{
    std::string par_js_path = exe_path + "/../../../src/visual/visual.partial.js";
    std::ifstream par_js(par_js_path);
    if(par_js.fail())
        throw cgrame_visual_error("Failed creating ifstream " + par_js_path);
    std::string context_f_path = exe_path + "/../../../output/context-div.js";
    std::ofstream context_f(context_f_path, std::ios::trunc);
    if(context_f.fail())
        throw cgrame_visual_error("Failed creating ofstream on " + context_f_path);
    std::string f_path = exe_path + "/../../../output/CGRA.js";
    std::ofstream f(f_path, std::ios::trunc);
    if(f.fail())
        throw cgrame_visual_error("Failed creating ofstream on " + f_path);
 
    const auto& mrrg = cgra->getMRRG(II);;
    if(!mrrg.initiationInterval())
        throw cgrame_visual_error("MRRG Is Empty, Unable to Produce Visualization");
 
    // Fill context-div.js
    context_f << "document.write(\"\n";
    context_f << "    <div class=\\\"tab\\\">\\\n";
    context_f << "        <button class=\\\"tablinks\\\" onclick=\\\"showContext(event, 'context_0')\\\" id=\\\"defaultOpen\\\">Context 0</button>\\\n";
    for(int i = 1; i < mrrg.initiationInterval(); ++i)
        context_f << "        <button class=\\\"tablinks\\\" onclick=\\\"showContext(event, 'context_" << i << "')\\\">Context " << i << "</button>\\\n";
    context_f << "    </div>\\\n";
    for(int i = 0; i < mrrg.initiationInterval(); ++i)
        context_f << "    <div id=\\\"context_" << i << "\\\" class=\\\"tabcontent\\\"></div>\\\n";
    context_f << "\");\n";
 
    // Create top level function call
    f << "function draw() {\n";
    for(int i = 0; i < mrrg.initiationInterval(); ++i)
        f << "    draw_helper(" << i << ");\n";
    f << "}\n";
 
    std::vector<std::set<std::pair<int, std::string>, std::greater<std::pair<int, std::string>>>> cluster_type;
 
    int max_module_depth = 0;
    for(int i = 0; i < mrrg.initiationInterval(); ++i)
    {
        cluster_type.push_back(std::set<std::pair<int, std::string>, std::greater<std::pair<int, std::string>>>());
        for(auto n = mrrg.allNodesByCycle().at(i).begin(); n != mrrg.allNodesByCycle().at(i).end(); n++)
        {
            std::string s = n->second->getFullName();
            int count = 0;
            std::string::size_type pre_pos = 0;
            while(true)
            {
                auto pos = s.find('.', pre_pos);
                pre_pos = pos + 1;
                if(pos == std::string::npos)
                    break;
                else
                    cluster_type[i].insert(std::make_pair(++count, s.substr(0, pos)));
            }
            if(count > max_module_depth)
                max_module_depth = count;
        }
    }
 
    //if(max_module_depth <= 4)
    f << "var clusterColor = [ '#6698FF', '#27CEC8', '#30FF89', '#EEFF99' ];\n";
    //else
    //throw cgrame_visual_error("CGRA Architecture Is Too Complicated");
 
    // Create cluster types
    f << "var clusterTypes = [];\n";
    for(int i = 0; i < mrrg.initiationInterval(); ++i)
    {
        f << "clusterTypes.push([\n";
        for(auto & s : cluster_type[i])
        {
            f << "[\"" << s.second << "\", " << s.first << "],\n";
        }
        f << "]);\n";
    }
 
#ifndef NO_PREVIOUS_CYCLE_INPUT
    std::multimap<MRRGNode*, MRRGNode*> input_nodes;
#endif
 
    // Create nodes
    f << "var nodes = [];\n";
    for(int i = 0; i < mrrg.initiationInterval(); ++i)
    {
        std::set<std::string> nodes;
        f << "nodes.push(new vis.DataSet([\n";
        for(auto n = mrrg.allNodesByCycle().at(i).begin(); n != mrrg.allNodesByCycle().at(i).end(); n++)
        {
            if(n->second->type == MRRG_NODE_FUNCTION)
                f << "{ id: '" << n->second->getFullName() << "', label: '" << n->second->getFullName() <<"', shape: 'box'},\n";
            else
                f << "{ id: '" << n->second->getFullName() << "', label: '" << n->second->getFullName() <<"'},\n";
            nodes.insert(n->second->getFullName());
        }
        // Find nodes not belong in this cycle
        for(auto n = mrrg.allNodesByCycle().at(i).begin(); n != mrrg.allNodesByCycle().at(i).end(); ++n)
        {
            for(auto fanout = n->second->fanout.begin(); fanout != n->second->fanout.end(); fanout++)
            {
#ifndef NO_PREVIOUS_CYCLE_INPUT
                if((*fanout)->cycle != n->second->cycle) // Input node from previous cycle to the node found
                    input_nodes.insert(std::make_pair(*fanout, n->second));
#endif
                if(nodes.find((*fanout)->getFullName()) == nodes.end())
                {
                    f << "{ id: '" << **fanout << "' , label: '" << **fanout << "', color: '#B464FF'},\n";
                    nodes.insert((*fanout)->getFullName());
                }
            }
        }
        f << "]));\n";
    }
 
    // Create edges
    f << "var edges = [];\n";
    for(int i = 0; i < mrrg.initiationInterval(); ++i)
    {
        f << "edges.push(new vis.DataSet([\n";
        for(auto n = mrrg.allNodesByCycle().at(i).begin(); n != mrrg.allNodesByCycle().at(i).end(); ++n)
        {
            for(auto fanout = n->second->fanout.begin(); fanout != n->second->fanout.end(); fanout++)
            {
                f << "{ from: '" << (*(n->second)) << "', to: '" << (**fanout) << "', arrows: 'to' },\n";
            }
        }
        f << "]));\n";
    }
 
#ifndef NO_PREVIOUS_CYCLE_INPUT
    for(const auto & input_node : input_nodes)
    {
        f << "nodes[" << input_node.first->cycle << "].update([" << "{ id: '" << input_node.second->getFullName() << "', label: '" << input_node.second->getFullName() << "', color: 'grey'}]);\n";
        f << "edges[" << input_node.first->cycle << "].add([" << "{ from: '" << input_node.second->getFullName() << "', to: '" << input_node.first->getFullName() << "', arrows: 'to' }]);\n";
    }
#endif
 
    f << par_js.rdbuf();
}
 
void genMappingVisual(
    std::string exe_path, const MRRG& mrrg,
    const Mapping& mapping, const MappingGraph& mg,
    const CreateMappingGraphResult::ToMRRG& toMRRG
) {
    const auto vis_output_dir = exe_path + "/../../../output";
    const auto vis_src_dir = exe_path + "/../../../src/visual";
 
    if (mkdir(vis_output_dir.c_str(), 0777) && errno != EEXIST) {
        throw cgrame_visual_error(strerror(errno));
    }
 
    std::string par_js_path = vis_src_dir + "/visual.partial.js";
    std::ifstream par_js(par_js_path);
    if(par_js.fail())
        throw cgrame_visual_error("Failed creating ifstream " + par_js_path);
    std::string context_f_path = vis_output_dir + "/context-div.js";
    std::ofstream context_f(context_f_path, std::ios::trunc);
    if(context_f.fail())
        throw cgrame_visual_error("Failed creating ofstream on " + context_f_path);
    std::string f_path = vis_output_dir + "/CGRA.js";
    std::ofstream f(f_path, std::ios::trunc);
    if(f.fail())
        throw cgrame_visual_error("Failed creating ofstream on " + f_path);
    std::string cgra_html_path_out = vis_output_dir + "/CGRA.html";
    std::ofstream cgra_html_out(cgra_html_path_out, std::ios::trunc);
    if(cgra_html_out.fail())
        throw cgrame_visual_error("Failed creating ofstream on " + cgra_html_path_out);
    std::string cgra_html_path_in = vis_src_dir + "/CGRA.html";
    std::ifstream cgra_html_in(cgra_html_path_in);
    if(cgra_html_in.fail())
        throw cgrame_visual_error("Failed creating ifstream on " + cgra_html_path_in);
 
    if(!mrrg.initiationInterval())
        throw cgrame_visual_error("MRRG Is Empty, Unable to Produce Visualization");
 
    // copy CGRA.html
    cgra_html_out << cgra_html_in.rdbuf();
 
    // Fill context-div.js
    context_f << "document.write(\"\\\n";
    context_f << "    <div class=\\\"tab\\\">\\\n";
    context_f << "        <button class=\\\"tablinks\\\" onclick=\\\"showContext(event, 'context_0')\\\" id=\\\"defaultOpen\\\">Context 0</button>\\\n";
    for(int i = 1; i < mrrg.initiationInterval(); ++i)
        context_f << "        <button class=\\\"tablinks\\\" onclick=\\\"showContext(event, 'context_" << i << "')\\\">Context " << i << "</button>\\\n";
    context_f << "        <button class=\\\"tablinks\\\" onclick=\\\"showContext(event, 'context_" << mrrg.initiationInterval() << "')\\\">Mapping</button>\\\n";
 
    context_f << "    </div>\\\n";
 
    for(int i = 0; i < mrrg.initiationInterval(); ++i)
        context_f << "    <div id=\\\"context_" << i << "\\\" class=\\\"tabcontent\\\"></div>\\\n";
    context_f << "    <div id=\\\"context_" << mrrg.initiationInterval() << "\\\" class=\\\"tabcontent\\\"></div>\\\n";
 
    context_f << "\");\n";
 
    // Create top level function call
    f << "function draw() {\n";
    for(int i = 0; i <= mrrg.initiationInterval(); ++i)
        f << "    draw_helper(" << i << ");\n";
    f << "}\n";
 
    std::vector<std::set<std::pair<int, std::string>, std::greater<std::pair<int, std::string>>>> cluster_type;
 
    //Positions for the clusters
    std::unordered_map<std::string, std::pair<double, double>> cluster_position;
 
    // Determine clusters present from mrrg node names
    int max_module_depth = 0;
    for(int i = 0; i < mrrg.initiationInterval(); ++i)
    {
        cluster_type.push_back(std::set<std::pair<int, std::string>, std::greater<std::pair<int, std::string>>>());
        for(auto n = mrrg.allNodesByCycle().at(i).begin(); n != mrrg.allNodesByCycle().at(i).end(); ++n)
        {
            std::string s = n->second->getFullName();
            int count = 0;
            std::string::size_type pre_pos = 2;
            while(true)
            {
                auto pos = s.find('.', pre_pos);
                if(pos == std::string::npos)
                    break;
                else {
                    cluster_type[i].insert(std::make_pair(++count, s.substr(0, pos)));
 
                    // Get the position information for the submodule
                    auto posInfo = n->second->parent->getSubModulePosition(s.substr(pre_pos, pos-pre_pos));
               
                    if (posInfo.first) {
                        cluster_position.emplace(s.substr(0, pos), posInfo.second);
                    }
                }
                pre_pos = pos + 1;
            }
            if(count > max_module_depth)
                max_module_depth = count;
        }
    }
 
    //if(max_module_depth <= 4)
    f << "var clusterColor = [ '#6698FF', '#27CEC8', '#30FF89', '#EEFF99' ];\n";
    //else
    //throw cgrame_visual_error("CGRA's Architecture Is Too Complicated");
 
    // Create cluster types for full MRRG and their contexts
    f << "var clusterTypes = [];\n";
    for(int i = 0; i < mrrg.initiationInterval(); ++i)
    {
        f << "clusterTypes.push([\n";
        for(auto & s : cluster_type[i])
        {
            f << "[\"" << s.second << "\", " << s.first;
 
            // Position data
            if (cluster_position.find(s.second) != cluster_position.end()) {
                // Setting the position of clusters
                int xPos, yPos;
                std::tie(xPos, yPos) = getScaledPosition(cluster_position.at(s.second));
 
                f << ", " << xPos << ", " << yPos;
            }
 
            f << "],\n";
        }
        f << "]);\n";
    }
 
    // Mapping Graph Tab Submodules and Positions
    f << "clusterTypes.push([\n";
    for(int i = 0; i < mrrg.initiationInterval(); ++i)
    {
        for(auto & s: cluster_type[i])
        {
            f << "[\"" << s.second << "\", " << s.first;
 
            if (cluster_position.find(s.second) != cluster_position.end()) {
                // Setting the position of clusters
                int xPos, yPos;
                std::tie(xPos, yPos) = getScaledPosition(cluster_position.at(s.second));
 
                // Offset for cycle
                xPos += std::stoi(s.second)*10000;
                f << ", " << xPos << ", " << yPos;
            }
            f << "],\n";
        }
    }
    f << "]);\n";
 
 
#ifndef NO_PREVIOUS_CYCLE_INPUT
    std::multimap<MRRGNode*, MRRGNode*> input_nodes;
#endif
 
    // Create nodes
    f << "var nodes = [];\n";
    for(int i = 0; i < mrrg.initiationInterval(); ++i)
    {
        std::set<std::string> nodes;
        f << "nodes.push(new vis.DataSet([\n";
        for(auto n = mrrg.allNodesByCycle().at(i).begin(); n != mrrg.allNodesByCycle().at(i).end(); ++n)
        {
            std::string name = n->second->getFullName();
            if(n->second->type == MRRG_NODE_FUNCTION)
                f << "{ id: '" << name << "', label: '" << name <<"', shape: 'box'";
            else
                f << "{ id: '" << name << "', label: '" << name << "'";
            nodes.insert(name);
 
            auto dotIndex = name.rfind(".");
            std::pair<bool, std::pair<double, double>> posInfo;
            if (dotIndex != std::string::npos) {
                posInfo = n->second->parent->getNodePosition(name.substr(dotIndex+1));
            }
            else {
                auto colon_index = name.find(":");
                posInfo = n->second->parent->getNodePosition(name.substr(colon_index+1));
            }
 
            if (posInfo.first) {
                int xPos, yPos;
                std::tie(xPos, yPos) = getScaledPosition(posInfo.second);
 
                f << ", x:" << xPos << ", y:" << yPos << ", physics:false, fixed:true";
            }
 
            f << "},\n";
        }
        for(auto n = mrrg.allNodesByCycle().at(i).begin(); n != mrrg.allNodesByCycle().at(i).end(); ++n)
        {
            for(auto fanout = n->second->fanout.begin(); fanout != n->second->fanout.end(); fanout++)
            {
#ifndef NO_PREVIOUS_CYCLE_INPUT
                if((*fanout)->cycle != n->second->cycle) // Input node from previous cycle to the node found
                    input_nodes.insert(std::make_pair(*fanout, n->second));
#endif
                std::string name = (*fanout)->getFullName();
                if(nodes.find(name) == nodes.end()) {
                    f << "{ id: '" << **fanout << "' , label: '" << **fanout << "', color: '#B464FF'";
                    
                    int xPos, yPos;
                    auto posInfo = (*fanout)->parent->getNodePosition(name.substr(name.rfind(".")+1));
 
                    if (posInfo.first) {
                        std::tie(xPos, yPos) = getScaledPosition(posInfo.second);
                        // Offset for cycle, should probably match the screen width in the getScaledPosition function
                        if (std::stoi(name) != i) {
                           xPos += (i-std::stoi(name))*200;
                        }
 
                        f << ", x:" << xPos << ", y:" << yPos << ", physics:false, fixed:true";
                    }
                    f << "},\n";
                }
            }
        }
        f << "]));\n";
    }
 
    // Create nodes for mapping graph
    f << "nodes.push(new vis.DataSet([\n";
    for (const auto& mg_ndesc_and_node : mg.allNodes()) {
        const auto& mg_node = mg.getNodeRef(mg_ndesc_and_node.first);
        const auto& mrrg_node = mrrg.getNodeRef(toMRRG.at(mg_ndesc_and_node.first));
        const auto& name = mrrg_node.getFullName();
        // Nodes will have labels of: mrrg name | opgraph op
        f << "{ id: '" << name << "|" << mg_node.op_node_desc->getName() << "', label: '" << name << "|" << mg_node.op_node_desc->getName() << "'";
 
        if (mrrg_node.parent->getName().find("mux") != std::string::npos) {
            f << ", image: '../src/visual/Multiplexer.png', shape: 'image'";
        }
        else if (mrrg_node.parent->getName().find("ALU") != std::string::npos || mrrg_node.parent->getName().find("func") != std::string::npos) {
            f << ", image: '../src/visual/ALU.png', shape: 'image'";
        }
        else if (mrrg_node.type == MRRG_NODE_FUNCTION) {
            f <<", shape: 'box'";
        }
        
        int xPos = -1, yPos = -1;
        auto dotIndex = name.rfind(".");
        std::pair<bool, std::pair<double, double>> posInfo;
        if (dotIndex != std::string::npos) {
            posInfo = mrrg_node.parent->getNodePosition(name.substr(dotIndex+1));
        }
        else {
            posInfo = mrrg_node.parent->getNodePosition(name.substr(2));
        }
 
        if (posInfo.first) {
            std::tie(xPos, yPos) = getScaledPosition(posInfo.second);
            // Offset for cycle, should probably match the screen width in the getScaledPosition function
            xPos += std::stoi(name)*10000;
 
            f << ", x:" << xPos << ", y:" << yPos << ", physics:false, fixed:true";
        }
 
        f << ", color:";
        if (mrrg_node.type == MRRG_NODE_FUNCTION && xPos != -1) {
            f << "'skyblue'";
        }
        else if (mrrg_node.type == MRRG_NODE_FUNCTION) {
            f << "'coral'";
        }
        else {
            f << "'cornsilk'";
        }
 
        f <<"},\n";
    }
    f << "]));\n";
 
    // Create edges
    f << "var edges = [];\n";
    for(int i = 0; i < mrrg.initiationInterval(); ++i)
    {
        f << "edges.push(new vis.DataSet([\n";
        for(auto n = mrrg.allNodesByCycle().at(i).begin(); n != mrrg.allNodesByCycle().at(i).end(); ++n)
        {
            for(auto fanout = n->second->fanout.begin(); fanout != n->second->fanout.end(); fanout++)
            {
                f << "{ from: '" << (*(n->second)) << "', to: '" << (**fanout) << "', arrows: 'to' },\n";
            }
        }
        f << "]));\n";
    }
 
    // Create edges for the mapping
    f << "edges.push(new vis.DataSet([\n";
    for (auto & node: mg.allNodes()) {
        for (auto & fanout: mg.fanout(node.first)) {
            f << "{ from: '"  <<  mrrg.getNodeRef(toMRRG.at(node.first)).getFullName() << "|" << mg.getNodeRef(node.first).op_node_desc->getName() << "', to: '" << mrrg.getNodeRef(toMRRG.at(fanout)).getFullName() << "|" << mg.getNodeRef(fanout).op_node_desc->getName() << "', arrows: 'to' },\n";
        }
    }
    f << "]));\n";
 
#ifndef NO_PREVIOUS_CYCLE_INPUT
    for(const auto & input_node : input_nodes)
    {
        f << "nodes[" << input_node.first->cycle << "].update([" << "{ id: '" << input_node.second->getFullName() << "', label: '" << input_node.second->getFullName() << "', color: 'grey'}]);\n";
        f << "edges[" << input_node.first->cycle << "].add([" << "{ from: '" << input_node.second->getFullName() << "', to: '" << input_node.first->getFullName() << "', arrows: 'to' }]);\n";
    }
#endif
 
    f << "var nodeMapped = []; while(nodeMapped.push([]) <= " << mrrg.initiationInterval() << ");\n";
    for(const auto & map : mapping.getMapping())
    {
        for(const auto & mrrg_node : map.second)
        {
            f << "nodeMapped[" << mrrg.getNodeRef(mrrg_node).cycle << "].push({ id: '" << mrrg.getNodeRef(mrrg_node).getFullName() << "', color: 'red', title: '" << map.first->name << "' });\n";
        }
    }
 
    for (auto & node: mg.allNodes()) {
        f << "nodeMapped[" << mrrg.initiationInterval() << "].push({ id: '" << mrrg.getNodeRef(toMRRG.at(node.first)).getFullName() << "|" << mg.getNodeRef(node.first).op_node_desc->getName() << "', title: '" << mrrg.getNodeRef(toMRRG.at(node.first)).getFullName() << "|" << mg.getNodeRef(node.first).op_node_desc->getName() << "' });\n";
    }
 
    f << par_js.rdbuf();
}
 
std::pair<double, double> getScaledPosition(const std::pair<double, double> pos) {
    int width = 10000;
    int height = 10000;
    return {pos.first*width, pos.second*height};
}