InterActive.hpp

Go to the documentation of this file.

#ifndef InterActiveStandard_hpp
#define InterActiveStandard_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 InterActive : public virtual Annotation {
public:
  InterActive(); 
  ~InterActive() {}

  OA_ptr<ProcHandleIterator> getKnownProcIterator();

  // *************************************************************************

  bool isActive(ProcHandle proc, StmtHandle stmt);

  bool isActive(ProcHandle proc, MemRefHandle memref);

  OA_ptr<LocIterator> getActiveLocsIterator(ProcHandle proc);

  OA_ptr<StmtHandleIterator> getActiveStmtIterator(ProcHandle proc);

  OA_ptr<MemRefHandleIterator> getActiveMemRefIterator(ProcHandle proc); 

  int getNumIterUseful();

  int getNumIterVary();

  int getNumIterActive();

  int getActiveSizeInBytes();

  // *****************************************************************
  // Construction methods 
  // *****************************************************************

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

  void setNumIterUseful(int n);

  void setNumIterVary(int n);

  void setNumIterActive(int n);

  void setActiveSizeInBytes(int n);

  // *****************************************************************
  // Annotation Interface
  // *****************************************************************
  void output(IRHandlesIRInterface &ir);

  // *****************************************************************
  // Output
  // *****************************************************************

  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