segment_graph.h

Go to the documentation of this file.

#ifndef SEGMENT_GRAPH_H_INCLUDED_
#define SEGMENT_GRAPH_H_INCLUDED_

#include<iostream>
#include<map>
#include<set>
#include<utility>

#include "boost/graph/adjacency_list.hpp"
#include "boost/graph/graphviz.hpp"
#include "boost/algorithm/string.hpp"
#include "../internal_representation/module.h"

#include "rose.h"

#include "edge.h"
#include "function_annotation.h"
#include "port_call_path.h"
#include "segment.h"


#define DBG_SHOW(name,id) std::cout<<"\n\ndebug id: "<< id<<"  "<<#name<<" :  \n"<<name->unparseToString()<<std::endl;
namespace risc {

class Function;

namespace sg {

class SegmentGraph;

typedef boost::adjacency_list<boost::listS, // list (not vector!) of vertices (RD)
        boost::listS, boost::bidirectionalS, Segment, Edge,
        boost::property<boost::vertex_index_t, int> > Graph;
typedef boost::graph_traits<Graph>::vertex_descriptor VertexDescriptor; // ends up as 'void*' (RD)
typedef boost::graph_traits<Graph>::vertex_iterator VertexIterator;     // ends up as 'void*' (RD)
typedef boost::graph_traits<Graph>::edge_descriptor EdgeDescriptor;

class FunctionAnnotationAttributes;
class CachedFunctionAstAttributes;

struct SegmentCmp {
  bool operator()(                  // comparison of two VertexDescriptors
        const VertexDescriptor lhs,
        const VertexDescriptor rhs) const
  {
//  return lhs < rhs; // this would be the default behavior, comparing 2 pointers;
                      // because that's non-deterministic over multiple program runs,
                      // we compare instead the segment IDs (12/15/18, RD)

    Graph *FakeGraphHandle = NULL;  // we only need this type, not the value!
                                    // (the VertexDescriptors are 'void*' pointers,
                                    //  allowing direct access to the vertices
                                    //  without knowing the specific Graph object;
                                    //  this works only for a _list_ of vertices)

//  printf("DEBUG: SegmentCmp(lhs=%p, rhs=%p) lhs.id=%d, rhs.id=%d, lhs.node_id=%d, rhs.node_id=%d\n",
//          lhs, rhs,
//          (*FakeGraphHandle)[lhs].id_, (*FakeGraphHandle)[rhs].id_,
//          (*FakeGraphHandle)[lhs].node_id_, (*FakeGraphHandle)[rhs].node_id_);
//  assert((*FakeGraphHandle)[lhs].id_ == (*FakeGraphHandle)[rhs].id_ ?
//              lhs == rhs : true); // this fails in PSG cases
    assert((*FakeGraphHandle)[lhs].node_id_ == (*FakeGraphHandle)[rhs].node_id_ ?
                lhs == rhs : true); // this holds true even for PSG segments

    return (*FakeGraphHandle)[lhs].node_id_ < (*FakeGraphHandle)[rhs].node_id_;
  }
};

class SegmentGraph {

public:

  typedef std::set<SgFunctionDefinition*> FunctionCallBoundarySet;
  typedef std::set<VariantT> CCxxKeywordsBoundarySet;

  SegmentGraph();  
  SegmentGraph(FunctionCallBoundarySet function_boundaries);
  SegmentGraph(CCxxKeywordsBoundarySet keyword_boundaries);
  SegmentGraph(FunctionCallBoundarySet function_boundaries,
      CCxxKeywordsBoundarySet keyword_boundaries);

  typedef std::set<VertexDescriptor,              // RD's new one  (deterministic order by segment IDs)
                    SegmentCmp> SegmentSet;       // (comparison performed by SegmentCmp above)

  void get_wait_and_notifying_events();

  void find_module_segments();

  void print_psg_file(std::string file_name);

  void read_psg_from_file(std::string file_name);


  void replace_partial_function_call_nodes();

  void integrate_psg_into_sg(VertexDescriptor func_call_vertex_id, SgSymbol * func_sym);

  void remove_dangling_segments();
  
  std::vector<std::string> channel_seg_id_array_names_;

  std::set<VertexDescriptor> port_call_seg_vertexs_;

  std::vector<std::pair<VertexDescriptor, SgSymbol *> > 
    vertexID_symbol_pairs_of_partialFuncCallNodes_;  

  std::map< SgSymbol *  , std::vector<VertexDescriptor> >
    func_symbols_and_entrance_segVertex_;

  std::map< SgSymbol *  , std::vector<VertexDescriptor> >
    func_symbols_and_exit_segVertex_;

  int total_segment_nodes_;
   
  void clean_graph();


  void print_graph(std::string filename);


  void print_graph_read_write_access(std::string filename);


  void add_function(
        Thread *originating_thread,
        Function *function,
        bool duplicate_segments = false,
        bool is_simulation_process = true,
        std::string module_name = "");

  //DM 05/20/2019 same as add_function with extra functionality for sc_method
  void add_function_method(
        Thread *originating_thread,
        Function *function,
        bool duplicate_segments = false,
        bool is_simulation_process = true,
        std::string module_name = "");

  void read_write_analysis_of_segments();

  void set_all_segments_to_untouched();

private:

  bool static_analysis_;

  void handle_recursive_calls();


  void separate_variable_declaration_and_initializer_on_demand(
           SgBasicBlock *&bb, bool duplicate_segments, PortCallPath pcp);


  void decompose_expression_with_boundary_calls(SgExpression *expr,
           SgBasicBlock *&bb, bool duplicate_segments, PortCallPath pcp,
           int stmt_type = 0, SgStatement* parent = NULL,
           SgBasicBlock* body = NULL);

  void create_temp_variable_for_expression(SgExpression *expr,
           SgBasicBlock *&bb,
           int stmt_type = 0, SgStatement* parent = NULL,
           SgBasicBlock* body = NULL);

  std::string generate_unique_name(SgNode *node);

  std::string generate_unique_name(std::string);


  bool is_boundary_stmt(SgStatement const * const current_stmt);


  SgFunctionCallExp* has_function_call_with_boundary(SgExpression *expr,
                         bool duplicate_segments, PortCallPath pcp);


  bool should_decompose_function(SgExpression *expr, bool duplicate_segments,
      PortCallPath pcp, bool is_condition= false);


  SgFunctionDeclaration* contains_function_call_expression(SgExpression *expr);


  SegmentSet build_graph(
      SgStatement *current_stmt,
      SegmentSet current_segments,
      SegmentSet &break_segments,
      SegmentSet &continue_segments,
      bool duplicate_segments,
      PortCallPath pcp);


  void add_expression_to_segment(SegmentSet segments, SgNode *expr,
      PortCallPath pcp);


  CachedFunctionAstAttributes*
  build_segment_graph_for_function(
      SgFunctionDefinition *func_def,
      bool duplicate_segments,
      PortCallPath pcp,
      bool is_registered_b_transport = false);


  void insert_loop_edges(VertexDescriptor &loop_vertex,
           SegmentSet &current_segments,
           SegmentSet &continue_segments,
           SegmentSet &leaf_segments_of_loop);

  FunctionAnnotationAttributes* get_function_call_annotation(
      SgFunctionCallExp *func_call_exp);

  CachedFunctionAstAttributes*
  create_cached_function_attribute_for_annotated_function(
      SgNode* boundary_node,
      WAIT_CONSTRUCT wait_type,
      SegmentSet incoming_segments,
      bool is_conflict_free,
      PortCallPath pcp);

  void add_mapped_symbol_to_reference(SgFunctionCallExp *func_call,
           SgFunctionDefinition *func_def);

  void set_socket_attribute_for_dmi_object(
    SgFunctionCallExp *func_call,
    SgVariableDefinition* socket);

  void reference_analysis_hack_for_dmi_get_ptr(
    SgFunctionCallExp *func_call,
    SgFunctionDefinition *func_def,
    SgVariableDefinition *socket);


  void reference_analysis_hack_for_b_transport(
    SgFunctionCallExp *func_call,
    SgFunctionDefinition *func_def,
    SgVariableDefinition *socket);

  void reference_analysis_hack_for_nb_transport(
    SgFunctionCallExp *func_call,
    SgFunctionDefinition *func_def,
    SgVariableDefinition *socket);


  void forward_reference_function_parameters(SgFunctionCallExp *func_call_exp);

  void mark_not_conflict_free_func_calls_in_segment(
           SgNode *stmt,
           SegmentSet segments);


  FunctionAnnotation*
  analyze_prepended_pragmas_for_annotation(SgFunctionDeclaration *func_decl);

  SegmentSet duplicate_segments(SegmentSet segments);

  SegmentSet duplicate_empty_segments(SegmentSet segments);

  FunctionCallBoundarySet function_boundaries_;

  CCxxKeywordsBoundarySet keyword_boundaries_;

  std::set<VertexDescriptor> recursive_function_calls_;

  static int counter;

  bool follow_function_call(SgFunctionDeclaration *func_decl);

  void set_socket_call_CachedFunctionAstAttributes(
    SgFunctionDeclaration *func_decl,
    bool duplicate_segments,
    PortCallPath pcp
  );


  
public:
  void analyze_TLM2_container_final_mapping();
  
  bool has_transition(int seg_id_from, int seg_id_to);

  VertexDescriptor id_to_vertex_descriptor(int seg_id);

  Graph graph_;

  std::set<VertexDescriptor> precached_function_segments_;

  std::set<SgFunctionCallExp*> port_calls_;


  bool is_succesfully_created_;

  std::unordered_map<SgFunctionDeclaration*, 
                     std::vector<int> >
                     func_socket_offset_mapping_;

  std::unordered_map<SgFunctionCallExp*, //socket_x->b_transport(..)
                     std::vector<int> > // <socket id, offset to be instrumented before the bt>
                     bt_socket_offset_mapping_;

  std::unordered_set<SgFunctionCallExp*> b_transport_calls_;

  std::unordered_set<SgVariableSymbol*> Tlm2_containers_;
};

} // end of namespace sg

} // end of namespace risc

#endif /* SEGMENT_GRAPH_H_INCLUDED_ */

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