omp_lowering.h

#include "astQuery.h"
//#include "sage3basic.h"
 
#ifndef OMP_LOWERING_H
#define OMP_LOWERING_H 
 
#include "OmpAttribute.h"
 
namespace OmpSupport
{
  // 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 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 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);
 
  // It calls the ROSE AST outliner internally. 
  SgFunctionDeclaration* generateOutlinedTask(SgNode* node, std::string& wrapper_name, std::set<SgVariableSymbol*>& syms);
 
  ROSE_DLL_API void transOmpVariables(SgStatement * ompStmt, SgBasicBlock* bb1, SgExpression* orig_loop_upper = NULL, bool withinAcceleratorModel= false);
 
  ROSE_DLL_API SgInitializedNamePtrList collectAllClauseVariables (SgOmpClauseBodyStatement * clause_stmt);
 
  ROSE_DLL_API SgInitializedNamePtrList collectClauseVariables (SgOmpClauseBodyStatement * clause_stmt, const VariantT& vt);
 
  ROSE_DLL_API SgInitializedNamePtrList collectClauseVariables (SgOmpClauseBodyStatement * clause_stmt, const VariantVector& vvt);
 
  ROSE_DLL_API SgExpression* getClauseExpression (SgOmpClauseBodyStatement * clause_stmt, const VariantVector& vvt);
 
  ROSE_DLL_API bool isInClauseVariableList(SgInitializedName* var, SgOmpClauseBodyStatement * clause_stmt, const VariantT& vt);
 
  ROSE_DLL_API bool isInClauseVariableList(SgInitializedName* var, SgOmpClauseBodyStatement * 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, SgOmpClauseBodyStatement * clause_stmt, const VariantT& vt);
 
  ROSE_DLL_API SgOmpVariablesClause* buildOmpVariableClause(SgOmpClauseBodyStatement * clause_stmt, const VariantT& vt);
 
  ROSE_DLL_API int removeClause (SgOmpClauseBodyStatement * clause_stmt, const VariantT& vt);
 
  ROSE_DLL_API bool hasClause(SgOmpClauseBodyStatement* clause_stmt, const VariantT & vt);
 
  ROSE_DLL_API Rose_STL_Container<SgOmpClause*>  getClause(SgOmpClauseBodyStatement* clause_stmt, const VariantT & vt);
 
  ROSE_DLL_API bool useStaticSchedule(SgOmpClauseBodyStatement* omp_loop);
 
  ROSE_DLL_API SgOmpClause::omp_reduction_operator_enum getReductionOperationType(SgInitializedName* init_name, SgOmpClauseBodyStatement* clause_stmt);
 
  ROSE_DLL_API SgExpression* createInitialValueExp(SgOmpClause::omp_reduction_operator_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 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