MPICFGIRInterface.hpp

Go to the documentation of this file.

#ifndef MPICFGIRInterface_h
#define MPICFGIRInterface_h

//-----------------------------------------------------------------------------
// This file contains the abstract base classes for the IR interface.
//
// See the top level README for a description of the IRInterface and
// how to use it.
//-----------------------------------------------------------------------------

#include <iostream>
#include <map>
#include <list>

#include <OpenAnalysis/Utils/OA_ptr.hpp>
#include <OpenAnalysis/IRInterface/IRHandles.hpp>
#include <OpenAnalysis/IRInterface/ConstValBasicInterface.hpp>
#include <OpenAnalysis/IRInterface/ConstValIntInterface.hpp>
#include <OpenAnalysis/IRInterface/EvalToConstVisitorIRInterface.hpp>
#include <OpenAnalysis/ExprTree/ExprTree.hpp>

// FIXME: this needs to go away at some point
#include "CFGIRInterface.hpp"

namespace OA {
  namespace MPICFG {

//
//  The Open64IRInterface in UseNewOA has a mapping of strings to IRProcType
//  so if we add more recognizable types here, we should add them there, too
//  Also, there is a mapping of IRProcType and IRParamType to param position
//  (int) there also.  Update that structure when a new IRProcType is added.
enum IRProcType {
  MPI_NONE,                   // Any non-MPI call
  MPI_OTHER,                  // Any MPI call not covered below
  MPI_INIT,                   // MPI_Init - called before any other MPI call
  MPI_COMM_RANK,              // MPI_Comm_Rank - get own process id in group 
  MPI_COMM_SIZE,              // MPI_Comm_Size - # processors in group
  MPI_COMM_DUP,               // MPI_Comm_Dup - duplicates oldcomm to comm 
  MPI_COMM_SPLIT,             // MPI_Comm_Split - partition comm to subcomm
  MPI_SEND,                   // MPI_Send
  MPI_RECV,                   // MPI_Recv
  MPI_BCAST,                  // MPI_Bcast
  MPI_REDUCE,                 // MPI_Reduce
  MPI_FINALIZE                // MPI_Finalize
};

//  The Open64IRInterface in UseNewOA has a mapping of IRProcType and
//  IRParamType to parameter position.  So when a new IRProcType is added
//  that has a parameter type not in IRParamType, update here.
enum IRParamType {
  BUF,
  COLOR,
  COMM,
  COUNT,
  DATATYPE,
  DEST,
  GROUP,
  IERROR,
  KEY,
  NEWCOMM,
  OP,
  RANK,
  RECVBUF,
  ROOT,
  SENDBUF,
  SIZE,
  SOURCE,
  STATUS,
  TAG
};

//    typedef pair<IRProcType,IRParamType> ProcParamPair;

// return type for examining a parameter expression tree
// first() is true if second() has a useful const value from the parameter
typedef std::pair<bool,OA_ptr<ConstValBasicInterface> > MaybeConstValue;

//------------------------------------
// for use in MPICFGIdRankVar

enum IRRankVarStmtType { 
  RANK_NO_STMT,    // not a statement, error situation
  RANK_ANY_STMT,   // Any statement not covered below
  RANK_DEF_STMT    // A statement with a call to MPI_COMM_RANK
};

enum IRCopyStmtType {
  COPY_NO_STMT,    // not a statement, error situation
  COPY_ANY_STMT,   // Any statement not covered below
  COPY_STMT        // A statement involving only (target = use) pairs
};

//typedef std::pair<MemRefHandle,MemRefHandle> CopyStmtPair;
class CopyStmtPairIterator {
  public:
    CopyStmtPairIterator() {}
    virtual ~CopyStmtPairIterator() {}

    virtual MemRefHandle currentSource() const = 0;
    virtual MemRefHandle currentTarget() const = 0;

    virtual bool isValid() const = 0;
                    
    virtual void operator++() = 0;
    void operator++(int) { ++*this; }
};

//typedef std::list<CopyStmtPair> CopyStmtPairList;

//-----------------------------
// for use in MPICFGIdRankVar and MPICFGUpdateLabels

enum LatticeType {TOP, VALUE, BOTTOM};

//-----------------------------
// for use in MPICFGUpdateLabels
//----------------
// We want to eventually get here
enum RelOp {GREATER,LESSER,EQUAL,GREATER_EQUAL,LESSER_EQUAL,NOT_EQUAL};
//enum BoolOp {AND, OR, NOT};
//enum RelOp {EQUAL, NOT_EQUAL};
enum BoolOp {AND, OR};
// RankExprTree has toString functions for RelOp, BoolOp, and LatticeType



class MPICFGIRInterface : public virtual IRHandlesIRInterface,
                      public virtual EvalToConstVisitorIRInterface 
{
 public:
  MPICFGIRInterface() { }
  virtual ~MPICFGIRInterface() { } 
  
  //--------------------------------------------------------
  // Iterators
  //--------------------------------------------------------

  virtual OA_ptr<IRStmtIterator> getStmtIterator(ProcHandle h) = 0; 

  virtual OA_ptr<IRCallsiteIterator> getCallsites(StmtHandle h) = 0;

  // Get IRCallsiteParamIterator for a callsite. 
  virtual OA_ptr<IRCallsiteParamIterator> getCallsiteParams(ExprHandle h) = 0;
 
  //--------------------------------------------------------
  // Symbol Handles
  //--------------------------------------------------------

  virtual SymHandle getSymHandle(ExprHandle expr) = 0;
  
  virtual SymHandle getProcSymHandle(ProcHandle h) = 0;
 
  //--------------------------------------------------------
  // Utilities
  //--------------------------------------------------------

  virtual std::string toString(const SymHandle h) = 0;

  virtual std::string toString(const ExprHandle h) = 0;

  virtual OA_ptr<ExprTree> getExprTree(ExprHandle h) = 0;

  //--------------------------------------------------------
  // MPI-specific functionalities
  //--------------------------------------------------------

  virtual IRProcType getMPICFGProcType(SymHandle h) = 0; 

  virtual bool isMPICFGAnyTag(ConstValHandle h) = 0;

  virtual bool isMPICFGAnyTag(ConstSymHandle h) = 0;

  virtual bool isMPICFGAnyTag(OA_ptr<ConstValBasicInterface> c) = 0;

  virtual bool isMPICFGAnySource(ConstValHandle h) = 0;

  virtual bool isMPICFGAnySource(ConstSymHandle h) = 0;

  virtual bool isMPICFGAnySource(OA_ptr<ConstValBasicInterface> c) = 0;

  // The following routines return expression handles to the 
  // requested parameter of the MPI call of the given callsite
  // represented by an expression handle.  The algorithms
  // behind these routines will be dependent upon the MPI interface
  // in the source language of the application program.  Currently,
  // only implemented for Fortran90.

  // the MPI call within the given expression handle callsite
  virtual ExprHandle getMPICFGCommParam(OA::ExprHandle h) = 0;

  // the MPI call within the given expression handle callsite
  virtual ExprHandle getMPICFGDataTypeParam(OA::ExprHandle h) = 0;

  // the MPI call within the given expression handle callsite
  virtual ExprHandle getMPICFGDestParam(OA::ExprHandle h) = 0;

  // the MPI call within the given expression handle callsite
  virtual ExprHandle getMPICFGGroupParam(OA::ExprHandle h) = 0;

  // the MPI call within the given expression handle callsite
  virtual ExprHandle getMPICFGOpParam(OA::ExprHandle h) = 0;

  // the MPI call within the given expression handle callsite
  virtual ExprHandle getMPICFGRankParam(OA::ExprHandle h) = 0;

  // the MPI call within the given expression handle callsite
  virtual ExprHandle getMPICFGRootParam(OA::ExprHandle h) = 0;

  // the MPI call within the given expression handle callsite
  virtual ExprHandle getMPICFGSizeParam(OA::ExprHandle h) = 0;

  // the MPI call within the given expression handle callsite
  virtual ExprHandle getMPICFGSourceParam(OA::ExprHandle h) = 0;

  // the MPI call within the given expression handle callsite
  virtual ExprHandle getMPICFGTagParam(OA::ExprHandle h) = 0;

  //--------------------------------------------------------
  // DEBUGGING
  //--------------------------------------------------------

  // !Given an expression handle to a parameter, 
  // pretty-print it to the output stream os.
  virtual void dumpMPICFGparam(ExprHandle h, std::ostream& os) = 0;

  // should be removed after testing
  virtual int returnOpEnumValInt(OA::OpHandle op) = 0;

  virtual void dump(StmtHandle stmt, std::ostream& os) 
    { os << "Override CFGIRInterfaceDefault::dump(StmtHandle,os)"; }

  // given a ConstValBasicInterface, print out value if any
  virtual std::string toString(OA_ptr<OA::ConstValBasicInterface> cvPtr) = 0;

  //--------------------------------------------------------
  // Following are extra for ManagerMPICFGIdRankVars
  //--------------------------------------------------------

  // But defined above class MPICFGIRInterface
  //enum IRRankVarStmtType { RANK_NO_STMT, RANK_ANY_STMT, RANK_DEF_STMT };

  virtual IRRankVarStmtType getMPICFGRankVarStmtType(OA::StmtHandle h) = 0;

  virtual MemRefHandle getMPICFGRankDefMemRef(OA::StmtHandle h) = 0;
  
  virtual StmtHandle getStmtFromMemRef(OA::MemRefHandle h) = 0;
  
  virtual OA_ptr<MemRefHandleIterator> getAllMemRefs(StmtHandle stmt) = 0;
  
  virtual OA_ptr<MemRefHandleIterator> getDefMemRefs(StmtHandle stmt) = 0;

  virtual OA_ptr<MemRefHandleIterator> getUseMemRefs(StmtHandle stmt) = 0;
  
  virtual std::string toString(const StmtHandle h) = 0;

  virtual std::string toString(const MemRefHandle h) = 0;

  virtual OA_ptr<ConstValBasicInterface> getConstValBasic(ConstSymHandle c) = 0;
  
  virtual OA_ptr<ConstValBasicInterface> getConstValBasic(ConstValHandle c) = 0;

  virtual IRCopyStmtType getCopyStmtType(OA::StmtHandle h) = 0;; 
  
  virtual OA_ptr<CopyStmtPairIterator> 
      getCopyStmtPairIterator(OA::StmtHandle h) = 0;

  //--------------------------------------------------------
  // Following are extra for ManagerMPICFGUpdateLabels
  //--------------------------------------------------------

  virtual bool isaRelOp(OA::OpHandle h) = 0;
  virtual OA::MPICFG::RelOp getRelOp(OA::OpHandle h) = 0;

  virtual OA_ptr<ConstValIntInterface> 
      getConstValInt(OA_ptr<ConstValBasicInterface> c) =0;

  virtual ExprHandle getLoopCondition(OA::StmtHandle h) =0;
  virtual ExprHandle getCondition(OA::StmtHandle h) =0;
  virtual ExprHandle getSMultiCondition (OA::StmtHandle h, int bodyIndex) =0;
  virtual ExprHandle getSMultiTest(OA::StmtHandle h) =0;
  virtual ExprHandle getUMultiCondition(OA::StmtHandle h, int targetIndex) =0;
  virtual ExprHandle getUMultiTest(OA::StmtHandle h) =0;

  // get number of cases or targets for use in get*MultiCondition above
  virtual int numMultiCases(OA::StmtHandle h)=0;
  virtual int numUMultiTargets(OA::StmtHandle h)=0;

  virtual CFG::IRStmtType getCFGStmtType(StmtHandle h) = 0; 

  virtual OA_ptr<OA::ConstValBasicInterface>
    getConstFromSwitchCase(OA::ExprHandle h) = 0;

  //--------------------------------------------------------
  // Following are extra for ManagerInterMPICFGUpBound
  //--------------------------------------------------------

  //  virtual OA_ptr<IRProcIterator> getProcIterator(PU_Info* puForest) = 0;
  // wish the above existed!  Am passing the iterator directly into 
  // the performAnalysis routine from the test program

};


  } // end of namespace MPICFG
} // end of namespace OA

#endif // MPICFGIRInterface_h