segment.h

Go to the documentation of this file.

#ifndef SEGMENT_H_INCLUDED_
#define SEGMENT_H_INCLUDED_

#include<vector>
#include<set>
#include<map>
#include<iostream>

#include "rose.h"
#include "boost/graph/properties.hpp" // needed for color

#include "mapped_variable.h" // needed for Conflict

#include "time.h" // needed for Time
#include "port_call_path.h"
#include "../internal_representation/thread.h"

namespace risc {

namespace sg {

class Segment {

public:

  bool is_b_transport_seg_;
  
  SgFunctionDeclaration* b_transport_func_;
  
  SgFunctionCallExp* b_transport_;
  
  bool is_fake_segment_;


  bool is_sc_fifo_port_call_;

  bool is_simulation_process_;


  int segment_node_id_;
  
  std::string function_name_entrance_;

  std::string function_name_exit_;

  std::string module_name_;
  
  std::string non_defining_function_call_name_;
  
  std::string pcp_port_name_;

  SgNode* pcp_port_;

  //psg cloning ZC step 1
  bool is_entrance_to_channel_method_;

  //psg cloning ZC step 5
  SgFunctionCallExp* port_call_func_exp_;

  std::string unique_port_call_name_;
  //end

  //psg cloning ZC step 5
  std::string channel_seg_ids_array_name_;
  //end


  int psg_id_;
 
  int node_id_;

  bool is_redacted_;

  static int node_counter;
  
  enum ERead {NonRead = 0, Read = 1};
  enum EWrite {NonWrite = 0, Write = 1};

  //typedef std::vector<const SgStatement*> Statements;
  typedef std::list<NodeWithPath> Expressions;
  boost::default_color_type color;

  enum Status {Untouched = 0, Touched = 1};
  Status color_for_communication_graph_;
  Status helper_for_graph_algorithms_;

  Expressions expressions_;

  bool debugging_;

  bool inlined_segment_;

  bool is_channel_segment_;

  int wait_offset_;

  std::set<Conflict> conflicts_;

  Segment(SgNode *boundary_node,
          bool inlined_segment,
          int psg_id = 0,
          bool is_fake_segment_ = false,
          bool is_simulation_process = false);

  Segment(const Segment &other);

  PortCallPath pcp_;

  void analyze_segment();

  void analyze_expression(SgNode *expression, ERead read, EWrite write, PortCallPath pcp);

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

  void add_expression(NodeWithPath nwp);

  bool operator==(const Segment &other);

  /*
   * \brief Merges the other segment in this segment.
   *        No statement will be doubled
   */
  void merge(const Segment &other);

  int id_;
  
  SgNode * boundary_node_;

  Thread *originating_thread_; // (RD, 07/10/18)

  static int id_counter;

  boost::default_color_type color_;

  std::set<SymbolWithPath> read_variables_;

  std::set<SymbolWithPath> write_variables_;

  std::set<SymbolWithPath> wait_events_; // (RD, 07/12/18)

  std::set<SymbolWithPath> notify_events_; // (RD, 07/12/18)
  
  std::map<SgVariableSymbol*, Time> events_notification_time_; // (RD, 07/12/18)

  bool calls_conflict_function_;

  Time get_min_waiting_time();

  bool deref_pointer_read_;
  bool deref_pointer_write_;

  bool contains_sc_stop_;

  bool waits_for_time_;

private:
  bool waits_for_time();

  void generic_payload_analysis_helper(SgVariableSymbol* var_sym, bool is_write, PortCallPath pcp_of_var);

  Time min_waiting_time_;
};

} // end of namespace sg

} // end of namespace risc

#endif /* SEGMENT_H_INCLUDED_ */

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