InterActiveFortran.hpp

Go to the documentation of this file.

#ifndef InterActiveFortran_hpp
#define InterActiveFortran_hpp

#include <cassert>
#include <iostream>
#include <map>
#include <OpenAnalysis/Utils/OA_ptr.hpp>
#include <OpenAnalysis/IRInterface/IRHandles.hpp>
#include <OpenAnalysis/DataFlow/LocDFSet.hpp>
#include <OpenAnalysis/Activity/ActiveStandard.hpp>
#include <OpenAnalysis/OABase/Annotation.hpp>

namespace OA {
  namespace Activity {


    class InterActiveFortran : public virtual Annotation {
  public:
    InterActiveFortran(); 
    
    ~InterActiveFortran();

    OA_ptr<ProcHandleIterator> getKnownProcIterator();

    bool isActive(SymHandle sym);


    bool isActive(ProcHandle proc, StmtHandle stmt);

    bool isActive(ProcHandle proc, MemRefHandle memref);


    void setActive(SymHandle sym);

    OA_ptr<SymHandleIterator> getActiveSymIterator();

    OA_ptr<MemRefHandleIterator> getActiveMemRefIterator(ProcHandle proc);

    OA_ptr<StmtHandleIterator> getActiveStmtIterator(ProcHandle proc);

    void mapProcToActive(ProcHandle p, OA_ptr<Activity::ActiveStandard> active);

    int getNumIterUseful();

    int getNumIterVary();

    int getNumIterActive();

    int getActiveSizeInBytes();

    void setNumIterUseful(int n);

    void setNumIterVary(int n);

    void setNumIterActive(int n);

    void setActiveSizeInBytes(int size);

    //*****************************************************************
    // Output
    //*****************************************************************
    void output(IRHandlesIRInterface &ir);

    void dump(std::ostream& os, OA_ptr<IRHandlesIRInterface> ir);

  private:
    // mapping of procedures to activity results
    std::map<ProcHandle,OA_ptr<Activity::ActiveStandard> > mProcToActiveMap;

    // set of active symbols from all procedures
    std::set<SymHandle> mActiveSymSet;
    bool mUnknownLocActive;
    int mSizeInBytes;

    // numIters:  number of iterations over nodes
    int mNumIterUseful;
    int mNumIterVary;
    int mNumIterActive;

    class ActivityProcIter : public virtual ProcHandleIterator,
                             public IRHandleSetIterator<ProcHandle>
    {
      public:
        ActivityProcIter(OA_ptr<std::set<ProcHandle> > pSet )
            : IRHandleSetIterator<ProcHandle>(pSet) {}
        ~ActivityProcIter() { }
    
        ProcHandle current() const
          { return IRHandleSetIterator<ProcHandle>::current(); }
        bool isValid() const  
          { return IRHandleSetIterator<ProcHandle>::isValid(); }
        void operator++() { IRHandleSetIterator<ProcHandle>::operator++(); }
        void reset() { IRHandleSetIterator<ProcHandle>::reset(); }
    };


};

  } // end of Activity namespace
} // end of OA namespace

#endif