/local/lecs/lecs/risc_v0.5.0/sources/build/risc_v0.5.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<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();

  void print_psg_file(std::string file_name);

  void read_psg_from_file(std::string);


  void replace_partial_function_call_nodes();

  void integrate_psg_into_sg(VertexDescriptor, SgSymbol *);

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

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

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


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

---