/local/lecs/lecs/risc_v0.4.2/sources/build/risc_v0.4.2/src/segment_graph/vertex_property_writer.h

Go to the documentation of this file.

#ifndef VERTEX_PROPERTY_WRITER_H_INCLUDED_
#define VERTEX_PROPERTY_WRITER_H_INCLUDED_

#include "rose.h"

#include "segment_graph.h"
#include "../internal_representation/design.h"
#include "../tools/variable_helper.h"
namespace risc {

namespace sg {

struct VertexPropertyWriter {

  static bool print_read_write_access;

  VertexPropertyWriter(Graph& graph);

  template <class Vertex>
  void operator() (std::ostream &out, Vertex v)
  {
    if(!PSG_MODE) out << "[shape=record,label=\"{ Segment ID: " << graph_[v].id_;
    //out << "[shape=record,label=\"{ Segment ID: " << graph_[v].id_;
    
    else {
      if(graph_[v].is_fake_segment){
        if(graph_[v].fake_segment_function_call_name!="")
          out << "[shape=record,style=dashed,label=\"{ Node ID: " << graph_[v].node_id_;
        else
          out << "[shape=record,style=dotted,label=\"{ Node ID: " << graph_[v].node_id_;      
      }
      else out << "[shape=record,style=bold,label=\"{ Node ID: " << graph_[v].node_id_;
    }
    if(graph_[v].boundary_node_) {
      std::string unparsed_stmt = graph_[v].boundary_node_->unparseToString();

      replace_escape_characters(unparsed_stmt);

      std::string temp =
        Rose::StringUtility::stripPathFromFileName(
            graph_[v].boundary_node_->get_file_info()->get_raw_filename());

      out << " (" << temp << ":"
          << graph_[v].boundary_node_->get_file_info()->get_line() << ")";

      // Here we writing the comment which is associated with the boundary
      // in the segment head
      const SgLocatedNode *located_node =
        isSgLocatedNode(graph_[v].boundary_node_);

      AttachedPreprocessingInfoType *comments =
        const_cast<SgLocatedNode*>(
            located_node)->getAttachedPreprocessingInfo();

      if(comments != NULL) {

        // We are iterating over all associated comments, however, we print
        // only the comment which is in the same line like the boundary
        // statement
        for(AttachedPreprocessingInfoType::iterator
            i  = comments->begin();
            i != comments->end();
            i++) {

          if(located_node->get_file_info()->get_line()
              == (*i)->getLineNumber()) {

            // parsing out the '//' at the beginning
            std::string str = (*i)->getString().substr(2,
                                                  (*i)->getString().length()-2);

            // deleting the line break break at the end
            str.erase(std::remove(str.begin(), str.end(), '\n'), str.end());
            out << "  " << str;
          }
        }
      }
    } else {

      SgNode *first_node = NULL;
      if(graph_[v].expressions_.size() != 0) {

        first_node = graph_[v].expressions_.front().node_;

        if(first_node) {
          SgFunctionDefinition *func_def =
            SageInterface::getEnclosingFunctionDefinition(first_node);

          if(func_def) {

            SgClassDefinition *class_def =
              SageInterface::getEnclosingClassDefinition(func_def);

            if(class_def) {

              out << " [" << SageInterface::get_name(class_def)
                  << "::" << SageInterface::get_name(func_def) << "]";
            }
          }
        }
      }
// Only for communication graphs
//      out << "  INIT";
    }

    if(!graph_[v].pcp_.path_.empty()) {

      std::string temp(graph_[v].pcp_.path_.front()->unparseToString());
      replace_escape_characters(temp);
      out << " -- " << temp;
    }

    if(!VertexPropertyWriter::print_read_write_access) {
      for(Segment::Expressions::iterator
          expr_iter  = graph_[v].expressions_.begin();
          expr_iter != graph_[v].expressions_.end();
          expr_iter++) {

        //std::string unparsed_stmt = (*expr_iter)->unparseToString();
        std::string unparsed_stmt = expr_iter->node_->unparseToString();

        replace_escape_characters(unparsed_stmt);

        std::string temp =
          Rose::StringUtility::stripPathFromFileName(
            (*expr_iter).node_->get_file_info()->get_raw_filename());

// Only for communication graphs
//        if(isSgFunctionCallExp((*expr_iter))) {
          out << "|" << temp << ":"
              //<< (*expr_iter)->get_file_info()->get_line() << " "
              << expr_iter->node_->get_file_info()->get_line() << " ";

            if(!expr_iter->pcp_.path_.empty()) {
              out << " [ ";

              for(std::list<SgFunctionCallExp*>::iterator
                  port_call_iter  = expr_iter->pcp_.path_.begin();
                  port_call_iter != expr_iter->pcp_.path_.end();
                  port_call_iter++) {

                std::string temp((*port_call_iter)->unparseToString());
                replace_escape_characters(temp);

                std::list<SgFunctionCallExp*>::iterator temp2 = port_call_iter;
                out << temp;
                temp2++;
                if(temp2 != expr_iter->pcp_.path_.end()) {
                  out << " -> ";
                }

              }
              out << " ] ";
            }

          out << unparsed_stmt << "\\l";
//        }
      }
    } else {
      
      if(PSG_MODE){
        bool w = true;
      
        std::vector<std::string> write_var_list;
        std::vector<std::string> read_var_list;
        std::vector<std::string> rw_var_list;
        std::map<std::string,int> var_written;
        std::map<std::string,int> var_read;
        std::map<std::string,int> var_rw;
        
        
        for(std::list<SymbolWithPath>::iterator
          var_symbol_iter  = graph_[v].write_variables_.begin();
          var_symbol_iter != graph_[v].write_variables_.end();
          var_symbol_iter++) 
        {
          
          if(tools::is_local_variable(var_symbol_iter->symbol_)){
            continue;
          } 
          std::string var_name = (((var_symbol_iter->symbol_)->get_declaration())->get_qualified_name()).getString ();
          if(var_written[var_name] == 0){
            write_var_list.push_back(var_name);
            var_written[var_name]=1;
          }
        }
      
        for(std::list<SymbolWithPath>::iterator
          var_symbol_iter  = graph_[v].read_variables_.begin();
          var_symbol_iter != graph_[v].read_variables_.end();
          var_symbol_iter++) 
        {
        
          if(tools::is_local_variable(var_symbol_iter->symbol_)){
            continue;
          } 
          std::string var_name = (((var_symbol_iter->symbol_)->get_declaration())->get_qualified_name()).getString ();
          if(var_read[var_name] == 0){
            read_var_list.push_back(var_name);
            var_read[var_name]=1;
          }
        }
      
        for(std::vector<std::string>::iterator
          iter  = write_var_list.begin();
          iter != write_var_list.end();
          iter++) 
        {
        
          if(var_read[*iter]>0){
            rw_var_list.push_back(*iter);
            var_rw[*iter]=1;
          }
        }
      
        for(std::vector<std::string>::iterator
          iter  = rw_var_list.begin();
          iter != rw_var_list.end();
          iter++) 
        {        
          if(w) out << "\" + \n                     \"";
          out << "| (RW) "
              << *iter;
          out << "\\l";
        }
        
        for(std::vector<std::string>::iterator
          iter  = write_var_list.begin();
          iter != write_var_list.end();
          iter++) 
        {
          if(var_rw[*iter]==1) continue;
          
          if(w) out << "\" + \n                     \"";
          out << "| (W) "
              << *iter;
          out << "\\l";
        }
        
        for(std::vector<std::string>::iterator
          iter  = read_var_list.begin();
          iter != read_var_list.end();
          iter++) 
        {
          if(var_rw[*iter]==1) continue;
          
          if(w) out << "\" + \n                     \"";
          out << "| (R) "
              << *iter;
          out << "\\l";
        }
        
      
        std::map <std::string,int> event_notified;
        std::map <std::string,int> event_waited;
        
        //print wait and notify events
        for(std::vector<SgVariableSymbol*>::iterator iter = graph_[v].wait_event_symbols.begin();
          iter != graph_[v].wait_event_symbols.end();
          iter++)
        {
          if( event_waited[((*iter)->get_declaration()->get_qualified_name()).getString ()] >0) continue;
          event_waited[((*iter)->get_declaration()->get_qualified_name()).getString ()]=1;
          if(w) out << "\" + \n                     \"";
          out << "| (wait_event) " << ((*iter)->get_declaration()->get_qualified_name()).getString ();
          out << "\\l";
          w=true;
        }
          
        for(std::vector<SgVariableSymbol*>::iterator iter = graph_[v].notify_event_symbols.begin();
          iter != graph_[v].notify_event_symbols.end();
          iter++)
        {
          if( event_notified[((*iter)->get_declaration()->get_qualified_name()).getString ()] >0) continue;
          event_notified[((*iter)->get_declaration()->get_qualified_name()).getString ()]=1;
          if(w) out << "\" + \n                     \"";
          
          out << "| (notify_event) " << ((*iter)->get_declaration()->get_qualified_name()).getString ();
          out << "\\l";
          w=true;
        }
        if(graph_[v].is_fake_segment){
          if(graph_[v].fake_segment_function_call_name!=""){
            out << "\" + \n                     \"";
            out << "| "
                << graph_[v].fake_segment_function_call_name;
            out << "\\l";
          }
        }
      }
      else{
        // printing write variables
        //for(std::list<SgVariableSymbol*>::iterator
        for(std::list<SymbolWithPath>::iterator
            var_symbol_iter  = graph_[v].write_variables_.begin();
            var_symbol_iter != graph_[v].write_variables_.end();
            var_symbol_iter++) {

          out << "| (W) "
              << SageInterface::get_name(var_symbol_iter->symbol_).erase(
                     SageInterface::get_name(var_symbol_iter->symbol_).length() - 8);

          if(!var_symbol_iter->pcp_.path_.empty()) {
            out << " [ ";

            for(std::list<SgFunctionCallExp*>::iterator
                port_call_iter  = var_symbol_iter->pcp_.path_.begin();
                port_call_iter != var_symbol_iter->pcp_.path_.end();
                port_call_iter++) {

              std::string temp((*port_call_iter)->unparseToString());
              replace_escape_characters(temp);

              std::list<SgFunctionCallExp*>::iterator temp2 = port_call_iter;
              out << temp;
              temp2++;
              if(temp2 != var_symbol_iter->pcp_.path_.end()) {
                out << " -> ";
              }

            }
            out << " ] ";
          }

          out << "\\l";
        }

        // printing read variables
        //for(std::list<SgVariableSymbol*>::iterator
        for(std::list<SymbolWithPath>::iterator
            var_symbol_iter  = graph_[v].read_variables_.begin();
            var_symbol_iter != graph_[v].read_variables_.end();
            var_symbol_iter++) {

          out << "| (R) "
              << SageInterface::get_name(var_symbol_iter->symbol_).erase(
                     SageInterface::get_name(var_symbol_iter->symbol_).length() - 8);

          if(!var_symbol_iter->pcp_.path_.empty()) {
            out << " [ ";

            for(std::list<SgFunctionCallExp*>::iterator
                port_call_iter  = var_symbol_iter->pcp_.path_.begin();
                port_call_iter != var_symbol_iter->pcp_.path_.end();
                port_call_iter++) {

              std::string temp((*port_call_iter)->unparseToString());
              replace_escape_characters(temp);

              std::list<SgFunctionCallExp*>::iterator temp2 = port_call_iter;
              out << temp;
              temp2++;
              if(temp2 != var_symbol_iter->pcp_.path_.end()) {
                out << " -> ";
              }

            }
            out << " ] ";
          }

          out << "\\l";
          
        }
        
      }
      
    }
    
    out << "}\"]";
    
    if(PSG_MODE){
      out << "\n                     /*\n";
      if(graph_[v].starting_segment_for_function!="")
        out << "                     starting segment for function: " << graph_[v].starting_segment_for_function << "\n";
      if(graph_[v].leaving_segment_for_function!="")
        out << "                     leaving segment for function: " << graph_[v].leaving_segment_for_function << "\n";
      
      if(graph_[v].is_fake_segment){
        if(graph_[v].fake_segment_function_call_name!="")
          out << "                     Partial Segment Type A, contains function: " << graph_[v].fake_segment_function_call_name << "\n";
        else
          out << "                     Partial Segment Type B, will be merged into other segments during integration\n";
      
      }
      
      if(graph_[v].is_simulation_process_segment)
        out << "                     starting segment for simulation process";
      if(graph_[v].module_name != "")
        out << " in module " << graph_[v].module_name <<"\n";
      if(graph_[v].deref_pointer_read_)
        out << "                     contains pointer read\n";
      if(graph_[v].deref_pointer_write_)
        out << "                     contains pointer write\n";
      out << "\n                     */\n";
    }

    /*
      // This is an alternative output strategy. Basically, everything is
      // represented in a (HTML) table, however, in my point of view it is
      // incredible ugly!
      out << "  [" << std::endl;
      out << "  shape = none" << std::endl;
      out << "  label = <<table border=\"1\" cellspacing=\"0\">" << std::endl;
      out << "            <tr><td>" << "ID: " << v << "</td></tr>" << std::endl;

      for(Segment::Statements::iterator
          stmt_iter  = graph_[v].statements_.begin();
          stmt_iter != graph_[v].statements_.end();
          stmt_iter++) {

        std::string unparsed_stmt = (*stmt_iter)->unparseToString();

        replace_escape_characters(unparsed_stmt);

        out << "            <tr><td>" << unparsed_stmt << "</td></tr>"
                                                       << std::endl;
      }
      out << "          </table>>" << std::endl;
      out << "  ]" << std::endl;
    */
  }

  void replace_escape_characters(std::string &unparsed_stmt);

  Graph& graph_;

  friend std::ostream& operator<< (std::ostream &out,
                           const VertexPropertyWriter &vpw)
  {
    return out;
  }
};

}; // end of namespace sg

}; // end of namespace risc

#endif /* VERTEX_PROPERTY_WRITER_H_INCLUDED_ */

/* ex: set softtabstop=2 tabstop=2 shiftwidth=2 expandtab: */

---