/local/lecs/lecs/risc_v0.4.2/sources/build/risc_v0.4.2/src/segment_graph/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,
        boost::listS, boost::bidirectionalS, Segment, Edge,
        boost::property<boost::vertex_index_t, int> > Graph;
typedef boost::graph_traits<Graph>::vertex_descriptor VertexDescriptor;
typedef boost::graph_traits<Graph>::edge_descriptor EdgeDescriptor;

typedef boost::graph_traits<risc::sg::Graph>::vertex_iterator VertexIterator;

class FunctionAnnotationAttributes;
class CachedFunctionAstAttributes;

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> SegmentSet;
  
  void get_wait_and_notifying_events();
  void find_module_segments(std::vector<Module*>& module_definitions_);
  void print_psg_file(std::string file_name);
  void read_psg_from_file(std::string);
  void write_psg_attributes(std::string);
  void replace_function_call_vertex_with_its_psg();
  void remove_dangling_segments();
  void integrate_psg_into_sg(VertexDescriptor, SgSymbol *);
  void count_segments_that_belongs_to_certain_psg();
  
  
  std::vector<std::pair<VertexDescriptor, SgSymbol *> > function_call_segments;  
  std::map< SgSymbol *  , std::vector<VertexDescriptor> > map_of_function_name_and_starting_segments;
  std::map< SgSymbol *  , std::vector<VertexDescriptor> > map_of_function_name_and_ending_segments;
  std::vector<SgExprStatement*> vector_of_statements_which_contain_non_defining_func_calls;  
  std::map<std::string, SegmentSet> map_of_function_name_and_leaving_segments_id_to_be_stored_into_a_psg_file;
  std::map<std::string, VertexDescriptor> map_of_function_name_and_starting_segments_id_to_be_stored_into_a_psg_file;
  std::set<VertexDescriptor> first_segments;
  std::map<VertexDescriptor, int> is_psg_first_segment_touched; 
  std::map<VertexDescriptor, std::vector<VertexDescriptor> > psg_segments; 
  std::map<int,int> count_of_segments_that_belongs_to_certain_psg;
  
  void clean_graph();


  void print_graph(std::string filename);


  void print_graph_read_write_access(std::string filename);


  void add_function(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);


  void create_temp_variable_for_expression(SgExpression *expr,
           SgBasicBlock *&bb);


  std::string generate_unique_name(SgNode *node);


  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);


  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);


  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 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);

public:

  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_;
};

} // end of namespace sg

} // end of namespace risc

#endif /* SEGMENT_GRAPH_H_INCLUDED_ */

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

---