/local/lecs/lecs/risc_v0.4.0/sources/build/risc_v0.4.0/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<set>
#include<utility>

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

#include "rose.h"

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


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(FunctionCallBoundarySet function_boundaries);
  SegmentGraph(CCxxKeywordsBoundarySet keyword_boundaries);
  SegmentGraph(FunctionCallBoundarySet function_boundaries,
      CCxxKeywordsBoundarySet keyword_boundaries);

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

  typedef std::set<VertexDescriptor> SegmentSet;

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


  void decompose_expression_with_boundary_calls(SgExpression *expr,
           SgBasicBlock *&bb, bool duplicate_segments);


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


  bool should_decompose_function(SgExpression *expr, bool duplicate_segments);


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


  void add_expression_to_segment(SegmentSet segments, SgNode *expr);


  CachedFunctionAstAttributes* build_segment_graph_for_function(
      SgFunctionDefinition *func_def, bool duplicate_segments);


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

  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: */

---