oagFpgaManager.h

Go to the documentation of this file.

#if !defined(oagFpgaManager_P)
#define oagFpgaManager_P

#include "oaDesignDB.h"
#include "oagFpga.h"
#include "oagFpgaRtlGraph.h"
//#include "oagFpgaReasoningEngine.h"
#include "oagAiGraph.h"
//#include "oagFpgaOccRef.h"
#include <list>
#include <map>
#include <set>

#define CACHE_LAST_MANAGER_LOOKUP

using namespace std;

namespace oagFpga {

// *****************************************************************************
// Manager
//
//
// *****************************************************************************

class Manager {
  friend class Synthesis;
  friend class ModGraph;
  friend class OccGraph;
  friend class AiModGraph;
  friend class ModuleCompiler;

  protected:

                        Manager(oa::oaDesign *design);
                       ~Manager();

  public:

    static inline bool         hasManager(oa::oaDesign *design) {
      assert(design);

      return design->getAppDefs().includes(managerAppDef);
    }
    static inline Manager*     get(oa::oaModule *module) {
      return get(module->getDesign());
    }
    static inline Manager*     get(oa::oaDesign *design) {
      assert(design);

#if defined(CACHE_LAST_MANAGER_LOOKUP)
      if (design == lastManagerDesign) {
        return lastManagerObject;
      } else if (hasManager(design)) {
        lastManagerDesign = design;
        lastManagerObject = static_cast<Manager*>(managerAppDef->get(design));
        return lastManagerObject;
      } else {
        lastManagerDesign = design;
        lastManagerObject = create(design);
        return lastManagerObject;
      }
#else
      if (hasManager(design)) {
        return static_cast<Manager*>(managerAppDef->get(design));
      } else {
        return create(design);   
      }
#endif
    }
    static Manager*            create(oa::oaDesign *design);
    static void                destroy(oa::oaDesign *design);

    
    static int          getSerializedSize(oa::oaDesign *design);
    static void         serialize(void* buf, oa::oaDesign *design);
    static int          unserialize(void* buf, oa::oaDesign *design);

    /*
    
    void                garbageCollect() {
        
        ai.garbageCollect();
    }    
    */

    
    bool                isStructural();
    void                print(ostream& os);
    
    /*
    int                 getLocalAIsize();
    int                 getHierarchicalAIsize();
    
    int                 getLocalAndAIsize();
    int                 getHierarchicalAndAIsize();

    int                 getLocalSeqNodeCount();
    int                 getHierarchicalSeqNodeCount();
       
    int                 getNumTotalInstances();
    int                 getNumLeafInstances();
*/
    
    
  public:

    oa::oaModBitNet *   getNetToBBConnection(BBRef ref);
    BBRef               getNetToBBConnection(oa::oaModBitNet *net);

    void                setNetToBBConnection(oa::oaModBitNet *net, BBRef bbRef) ;
    void                setNetToAiConnection(oa::oaModBitNet *net, oagAi::Ref aiRef) ;

    oa::oaModBitNet *   getNetToAiConnection(oagAi::Ref ref);
    oagAi::Ref          getNetToAiConnection(oa::oaModBitNet *net);

    void                removeNetToAiConnection(oa::oaModBitNet *net);

    inline const oagAi::Graph *  getAiGraph() const { 
        return &ai; 
    }
    inline oagAi::Graph *        getAiGraph() { 
        return &ai; 
    }


  protected:
  
    oagAi::Graph            ai;
    RtlGraph                bbg;
    oa::oaDesign           *design;

    /*
  private:

    // *****************************************************************************
    // struct TraversalState
    // *****************************************************************************
    struct TraversalState {
        enum{NOT_FOUND, 
             FOUND_AI,
             FOUND_NET}                              status;
        OccRef                                       nextAI;
        oa::oaOccBitNet                             *nextNet;

        TraversalState() { status = NOT_FOUND; }
    };
    
    void                           scanAIconnections( oa::oaOccBitNet *net, TraversalState &state );
    void                           scanUpHierarchy( oa::oaOccBitNet *net, TraversalState &state );
    void                           scanDownHierarchy( oa::oaOccBitNet *net, TraversalState &state );
    oa::oaOccBitNet*               searchForAIConnection(OccRef &g);
    
    oagAi::Ref                     flattenRecursively(oa::oaOccBitNet *net);
    oagAi::Ref                     flattenRecursively(OccRef &g);
    
    map<OccRef,oagAi::Ref>         preflattenedCache;
    list<OccRef>                   visitedStateBits;
    list<OccRef>                   cycleBreaks;
    std::set<OccRef>               visitedSet;

    int                            getHierarchicalAIsize(oa::oaDesign *design);
    int                            getHierarchicalAndAIsize(oa::oaDesign *design);
    int                            getHierarchicalSeqNodeCount(oa::oaDesign *design);
    int                            getNumTotalInstances(oa::oaDesign *design);
    int                            getNumLeafInstances(oa::oaDesign *design);
    void                           getStateBits(list<oa::oaOccBitNet*> &l, oa::oaOccurrence *occ);
    */
    
    BBRef                          prepareNetToBBConnection(oa::oaModBitNet *net);
    BBRef                          prepareNetToAiConnection(oa::oaModBitNet *net);
    
#if defined(CACHE_LAST_MANAGER_LOOKUP)
    static oa::oaDesign *lastManagerDesign;
    static Manager      *lastManagerObject;
#endif


};

}

#endif

---