omp_lowering.h

#include "astQuery.h"
//#include "sage3basic.h"
 
#ifndef OMP_LOWERING_H
#define OMP_LOWERING_H 
 
#include "ompSupport.h"
 
extern std::vector<SgFunctionDeclaration* >* outlined_function_list;
extern std::vector<SgDeclarationStatement *>* outlined_struct_list;
namespace OmpSupport
{
  //static std::vector<SgFunctionDeclaration* >* outlined_function_list = new std::vector<SgFunctionDeclaration *>();
 
  // OpenMP version info.
  extern bool enable_accelerator;  
 
  // A flag to control if device data environment runtime functions are used to automatically manage data as much as possible.
  // instead of generating explicit data allocation, copy, free functions. 
  extern  bool useDDE /* = true */;  
 
 
  int patchUpSharedVariables(SgFile* );
  // TODO:  patchUpDefaultVariables(SgFile* );
 
  int makeDataSharingExplicit( SgFile* );   
 
  // last edited by Hongyi on 07/24/2012. 
 
  // We support both Omni and GCC OpenMP runtime libraries
  enum omp_rtl_enum 
  {
    e_gomp,
    e_omni,
    e_last_rtl
  };
  extern unsigned int nCounter; // translation generated variable counter, used to avoid name collision
 
  extern omp_rtl_enum rtl_type; 
  typedef std::map<const SgVariableSymbol *, SgVariableSymbol *> VariableSymbolMap_t;
 
  void commandLineProcessing(std::vector<std::string> &argvList);
 
  void lower_omp(SgSourceFile*);
 
  void analyze_omp(SgSourceFile*);
 
  void insertRTLHeaders(SgSourceFile*);
 
  void insertRTLinitAndCleanCode(SgSourceFile* ); 
 
  //Pei-Hung Insert accelerator init 
  void insertAcceleratorInit(SgSourceFile* ); 
 
  class translationDriver: public AstSimpleProcessing
  { 
    protected:
      void visit(SgNode*);
  }; //translationDriver
 
  void transOmpParallel(SgNode* node);
 
  void transOmpTargetParallel(SgNode* node);
 
  void transOmpSections(SgNode* node);
 
  void transOmpTask(SgNode* node);
 
  void transUpirLoopParallel(SgNode* node);
 
  void transOmpLoop(SgNode* node);
 
  // The loop iteration count may exceed the max number of threads within a CUDA thread block. 
  // A loop scheduler is needed for real application.
  void transOmpTargetLoop(SgNode* node);
 
  void transOmpTargetLoop_RoundRobin(SgNode* node);
 
  //void transOmpDo(SgNode* node);
 
  void transOmpTarget(SgNode* node);
 
  void transOmpTargetData(SgNode* node);
 
 
  void transOmpBarrier(SgNode* node);
 
  void transOmpFlush(SgNode* node);
 
  void transOmpTaskwait(SgNode* node);
 
  void transOmpThreadprivate(SgNode* node);
 
  void transOmpOrdered(SgNode* node);
  void transOmpAtomic(SgNode* node);
  void transOmpCritical(SgNode* node);
  void transOmpMaster(SgNode* node);
  void transOmpSingle(SgNode* node);
  void transOmpMetadirective(SgNode* node);
  
  void transOmpSimd(SgNode *node);
  
  void transOmpUnroll(SgNode *node);
  
  void transOmpTile(SgNode *node);
 
  void createUpirStatementTree(SgSourceFile *file);
  SgStatement *getUpirParent(SgStatement *node);
  void setUpirRelationship(SgStatement *parent, SgStatement *child);
  Rose_STL_Container<SgNode *> mergeSgNodeList(Rose_STL_Container<SgNode *> node_list1, Rose_STL_Container<SgNode *> node_list2);
 
  // It calls the ROSE AST outliner internally.
  SgFunctionDeclaration* generateOutlinedTask(SgNode* node, std::string& wrapper_name,
                                              std::set<const SgVariableSymbol*>& syms,
                                              std::set<const SgVariableSymbol*>& pdSyms3,
                                              bool use_task_param = false);
 
  ROSE_DLL_API void transOmpVariables(SgStatement * ompStmt, SgBasicBlock* bb1, SgExpression* orig_loop_upper = NULL, bool withinAcceleratorModel= false);
 
  ROSE_DLL_API SgInitializedNamePtrList collectAllClauseVariables (SgUpirFieldBodyStatement * clause_stmt);
 
  ROSE_DLL_API SgInitializedNamePtrList collectClauseVariables (SgUpirFieldBodyStatement * clause_stmt, const VariantT& vt);
 
  ROSE_DLL_API SgInitializedNamePtrList collectClauseVariables (SgUpirFieldBodyStatement * clause_stmt, const VariantVector& vvt);
 
  ROSE_DLL_API SgExpression* getClauseExpression (SgStatement * clause_stmt, const VariantVector& vvt);
 
  ROSE_DLL_API bool isInClauseVariableList(SgInitializedName* var, SgUpirFieldBodyStatement * clause_stmt, const VariantT& vt);
 
  ROSE_DLL_API bool isInClauseVariableList(SgInitializedName* var, SgUpirFieldBodyStatement * clause_stmt, const VariantVector& vvt);
 
  ROSE_DLL_API int replaceVariableReferences(SgNode* root, SgVariableSymbol* oldVar, SgVariableSymbol* newVar);
 
  ROSE_DLL_API int replaceVariableReferences(SgNode* root,  VariableSymbolMap_t varRemap);
  // I decided to reuse the existing Outliner work instead of coding a new one
  //SgFunctionDeclaration* generateOutlinedFunction(SgNode* node);
 
  int replaceVariablesWithPointerDereference(SgNode* root, std::set<SgVariableSymbol*>& vars);
 
  ROSE_DLL_API void addClauseVariable(SgInitializedName* var, SgUpirFieldBodyStatement * clause_stmt, const VariantT& vt);
  ROSE_DLL_API void addUpirDataVariable(SgUpirFieldBodyStatement* target, SgUpirDataItemField* data_item);
 
  ROSE_DLL_API SgOmpVariablesClause* buildOmpVariableClause(SgUpirFieldBodyStatement * clause_stmt, const VariantT& vt);
 
  ROSE_DLL_API int removeClause (SgStatement * clause_stmt, const VariantT& vt);
 
  ROSE_DLL_API bool hasClause(SgStatement* clause_stmt, const VariantT & vt);
 
  ROSE_DLL_API Rose_STL_Container<SgOmpClause*> getClause(SgStatement* clause_stmt, const VariantT & vt);
 
  ROSE_DLL_API bool useStaticSchedule(SgUpirFieldBodyStatement* omp_loop);
 
  ROSE_DLL_API SgOmpClause::omp_reduction_identifier_enum getReductionOperationType(SgInitializedName* init_name, SgUpirFieldBodyStatement* clause_stmt);
 
  ROSE_DLL_API SgExpression* createInitialValueExp(SgOmpClause::omp_reduction_identifier_enum r_operator);
 
  ROSE_DLL_API std::string generateGOMPLoopStartFuncName (bool isOrdered, SgOmpClause::omp_schedule_kind_enum s_kind);
 
  ROSE_DLL_API std::string generateGOMPLoopNextFuncName (bool isOrdered, SgOmpClause::omp_schedule_kind_enum s_kind);
 
  ROSE_DLL_API std::string toString(SgOmpClause::omp_schedule_kind_enum s_kind);
 
  ROSE_DLL_API int patchUpPrivateVariables(SgFile*);
 
  ROSE_DLL_API int patchUpPrivateVariables(SgStatement* omp_loop);
 
  ROSE_DLL_API int patchUpFirstprivateVariables(SgFile*);
 
  std::set<SgInitializedName*> collectThreadprivateVariables();
 
  SgVariableDeclaration * buildAndInsertDeclarationForOmp(const std::string &name, SgType *type, SgInitializer *varInit, SgBasicBlock *orig_scope);
  SgBasicBlock* getEnclosingRegionOrFuncDefinition (SgNode *);
 
  ROSE_DLL_API bool isInClauseVariableList(SgOmpClause* cls, SgSymbol* var);
  ROSE_DLL_API bool isInUpirDataSharingList(SgOmpClause* data, SgSymbol* variable, SgOmpClause::upir_data_sharing_enum sharing_property);
  ROSE_DLL_API bool isInUpirDataSharingList(SgUpirFieldBodyStatement* target, SgSymbol* variable, SgOmpClause::upir_data_sharing_enum sharing_property);
  ROSE_DLL_API bool isInUpirDataSharingList(SgUpirFieldBodyStatement* target, SgSymbol* variable, std::set<SgOmpClause::upir_data_sharing_enum> sharing_property);
  ROSE_DLL_API bool isInUpirDataList(SgUpirFieldBodyStatement* target, SgSymbol* variable);
  ROSE_DLL_API SgUpirDataItemField* isInUpirDataList(SgOmpClause* target, SgSymbol* variable);
 
  ROSE_DLL_API bool isThreadprivate(SgSymbol* var);
 
  ROSE_DLL_API omp_construct_enum getDataSharingAttribute (SgSymbol* var, SgNode* anchor_node);
 
  ROSE_DLL_API omp_construct_enum getDataSharingAttribute (SgVarRefExp* varRef);
 
  ROSE_DLL_API bool isSharedAccess (SgVarRefExp* varRef);
 
  void extractMapClauses(Rose_STL_Container<SgOmpClause*> map_clauses,
      std::map<SgSymbol*, std::vector< std::pair <SgExpression*, SgExpression*> > > & array_dimensions,
      std::map<SgSymbol*, std::vector< std::pair< SgOmpClause::omp_map_dist_data_enum, SgExpression * > > > &  dist_data_policies, 
      SgOmpMapClause** map_alloc_clause, SgOmpMapClause** map_to_clause, SgOmpMapClause** map_from_clause, SgOmpMapClause** map_tofrom_clause);
  void categorizeMapClauseVariables( const SgInitializedNamePtrList & all_vars, // all variables collected from map clauses
      std::map<SgSymbol*,  std::vector < std::pair <SgExpression*, SgExpression*> > >&  array_dimensions, // array bounds  info as input
      std::set<SgSymbol*>& array_syms, // variable symbols which are array types (explicit or as a pointer)
      std::set<SgSymbol*>& atom_syms); // variable symbols which are non-aggregate types: scalar, pointer, etc
} // end namespace OmpSupport  
 
#endif //OMP_LOWERING_H