Home Research Papers Posters Manuals Talks Download People Help Internal

ck-com/ComlibStrategy.h

Go to the documentation of this file.

#ifndef COMLIBSTRATEGY_H
#define COMLIBSTRATEGY_H

#include "charm++.h"
#include "ckhashtable.h"
#include "convcomlibstrategy.h"
#include "ComlibLearner.h"
#include "envelope.h"

CkpvExtern(int, migrationDoneHandlerID);


enum CmhMessageType { CMH_ARRAYSEND, 
                      CMH_GROUPSEND, 
                      CMH_ARRAYBROADCAST, 
                      CMH_ARRAYSECTIONSEND, 
                      CMH_GROUPBROADCAST     };



class CharmMessageHolder : public MessageHolder{
 public:

  //#define BUGTRAPSIZE 5000

   //    int bug_trap[BUGTRAPSIZE];

    CkSectionID *sec_id;

    CkSectionID *copy_of_sec_id;  

    CkArrayID array_id; 

    CmhMessageType type; 
    
 CharmMessageHolder(char * msg, int proc, CmhMessageType t) : 
    MessageHolder((char *)UsrToEnv(msg), UsrToEnv(msg)->getTotalsize(), proc){
      type = t;
      sec_id = NULL;
      copy_of_sec_id = NULL;
      /*
      for(int i=0;i<BUGTRAPSIZE;i++){
        bug_trap[i] = 0;
      }
      
      checkme();
      */
    }
    
    /*
    void checkme() {
        for(int i=0;i<BUGTRAPSIZE;i++){
          if(bug_trap[i] != 0){
            CkPrintf("bug_trap[%d]=%d (should be 0) bug_trap[%d] is at %p\n", i, bug_trap[i], i, &bug_trap[i]);
            CkAbort("Corruption of CharmMessageHolder has occured\n");
          }
        }
    }
    */

    CharmMessageHolder(CkMigrateMessage *m) : MessageHolder(m) {
      /*
      for(int i=0;i<BUGTRAPSIZE;i++){
        bug_trap[i] = 0;
      }
      checkme();
      */
    }
    


    ~CharmMessageHolder(){
      //      checkme();
    }

    inline char * getCharmMessage() {
        return (char *)EnvToUsr((envelope *) data);
    }
    
    inline void saveCopyOf_sec_id(){
      //      ComlibPrintf("[%d] saveCopyOf_sec_id sec_id=%p NULL=%d\n", CkMyPe(), sec_id, NULL);

      //      checkme();

      if(sec_id!=NULL){

        //ComlibPrintf("Original has values: _nElems=%d, npes=%d\n", sec_id->_nElems, sec_id->npes );
        CkAssert(sec_id->_nElems>=0);
        CkAssert(sec_id->npes>=0);


        // Create a new CkSectionID, allocating its members
        copy_of_sec_id = new CkSectionID();
        copy_of_sec_id->_elems = new CkArrayIndex[sec_id->_nElems];
        copy_of_sec_id->pelist = new int[sec_id->npes];
        
        // Copy in the values
        copy_of_sec_id->_cookie = sec_id->_cookie;
        copy_of_sec_id->_nElems = sec_id->_nElems;
        copy_of_sec_id->npes = sec_id->npes;
        //      ComlibPrintf("Copy has values: _nElems=%d, npes=%d\n", copy_of_sec_id->_nElems, copy_of_sec_id->npes );
        for(int i=0; i<sec_id->_nElems; i++){
          copy_of_sec_id->_elems[i] = sec_id->_elems[i];
        }
        for(int i=0; i<sec_id->npes; i++){
          copy_of_sec_id->pelist[i] = sec_id->pelist[i];
        }

        // change local pointer to the new copy of the CkSectionID
        //      ComlibPrintf("saving copy of sec_id into %p\n", copy_of_sec_id);
      }

      //      checkme();

    }

    inline void freeCopyOf_sec_id(){
    /*   if(copy_of_sec_id != NULL){ */
/*      CkPrintf("delete %p\n", sec_id); */
/*      delete[] copy_of_sec_id->_elems; */
/*      delete[] copy_of_sec_id->pelist; */
/*      delete copy_of_sec_id; */
/*      copy_of_sec_id = NULL; */
/*       } */

//      checkme();

    }


    virtual void pup(PUP::er &p);
    PUPable_decl(CharmMessageHolder);
};



// Info classes that help bracketed streategies manage objects.
// Each info class points to a list of source (or destination) objects.
// ArrayInfo also access the array listener interface

class ComlibNodeGroupInfo {
 protected:
    CkNodeGroupID ngid;
    int isNodeGroup;

 public:
    ComlibNodeGroupInfo();

    void setSourceNodeGroup(CkNodeGroupID gid) {
        ngid = gid;
        isNodeGroup = 1;
    }

    int isSourceNodeGroup(){return isNodeGroup;}
    CkNodeGroupID getSourceNodeGroup();

    void pup(PUP::er &p);
};

class ComlibGroupInfo {
 protected:
    CkGroupID sgid, dgid;
    int *srcpelist, nsrcpes; //src processors for the elements
    int *destpelist, ndestpes;
    int isSrcGroup;   
    int isDestGroup;

 public:
    ComlibGroupInfo();
    ~ComlibGroupInfo();

    int isSourceGroup(){return isSrcGroup;}
    int isDestinationGroup(){return isDestGroup;}

    void setSourceGroup(CkGroupID gid, int *srcpelist=0, int nsrcpes=0);    
    void getSourceGroup(CkGroupID &gid);
    void getSourceGroup(CkGroupID &gid, int *&pelist, int &npes);

    void setDestinationGroup(CkGroupID sgid,int *destpelist=0,int ndestpes=0);
    void getDestinationGroup(CkGroupID &gid);
    void getDestinationGroup(CkGroupID &dgid,int *&destpelist, int &ndestpes);

    int *getCombinedCountList();
    //void getCombinedPeList(int *&pelist, int &npes);
    void pup(PUP::er &p);
};

class ComlibMulticastMsg;

class ComlibArrayInfo {
 private:

    CkArrayID src_aid;  
    CkArrayID dest_aid; 
    
    CkVec<CkArrayIndex> src_elements; 

    CkVec<CkArrayIndex> new_src_elements;

    CkVec<CkArrayIndex> dest_elements; 

    CkVec<CkArrayIndex> new_dest_elements;

    int isSrcArray;
    int isDestArray;

    bool isAllSrc; 
    int totalSrc; 
    bool isAllDest; 
    int totalDest; 
    
 public:
    ComlibArrayInfo();
    //~ComlibArrayInfo();

    void setSourceArray(CkArrayID aid, CkArrayIndex *e=0, int nind=0);
    int isSourceArray(){return isSrcArray;}
    CkArrayID getSourceArrayID() {return src_aid;}
    const CkVec<CkArrayIndex> & getSourceElements() {return src_elements;}

    void setDestinationArray(CkArrayID aid, CkArrayIndex *e=0, int nind=0);
    int isDestinationArray(){return isDestArray;}
    CkArrayID getDestinationArrayID() {return dest_aid;}
    const CkVec<CkArrayIndex> & getDestinationElements() {return dest_elements;}

    int getTotalSrc() {return totalSrc;}
    int getLocalSrc() {return src_elements.size();}

    void addNewLocalDestination(const CkArrayIndex &e) {
        CkAssert(e.nInts > 0);
        new_dest_elements.push_back(e);
    }

    void addNewLocalSource(const CkArrayIndex &e) {
        CkAssert(e.nInts > 0);
        new_src_elements.push_back(e);
    }
  
    void useNewSourceAndDestinations() {
      ComlibPrintf("[%d] useNewSourceAndDestinations previously had %d elements, now have %d elements\n", CkMyPe(), dest_elements.size(), new_src_elements.size() );
      dest_elements.removeAll();
      dest_elements = new_dest_elements;
      CkAssert(dest_elements.size() == new_dest_elements.size());
      new_dest_elements.removeAll();
      src_elements.removeAll();
      src_elements = new_src_elements;
      CkAssert(src_elements.size() == new_src_elements.size());
      new_src_elements.removeAll();
      if(com_debug)
        printDestElementList();
    }

    int newDestinationListSize(){ return new_dest_elements.size(); }
    int newSourceListSize(){ return new_src_elements.size(); }

    int getTotalDest() {return totalDest;}
    int getLocalDest() {return dest_elements.size();}

    void newElement(CkArrayID &id, const CkArrayIndex &idx);

    void localBroadcast(envelope *env);
    static int localMulticast(CkVec<CkArrayIndex> *idx_vec,envelope *env);
    static void deliver(envelope *env);

    void purge();

    int *getCombinedCountList();

    void printDestElementList();


    void pup(PUP::er &p);
};

class ComlibElementIterator : public CkLocIterator {
 public:
  CkVec<CkArrayIndex> *list;

  ComlibElementIterator(CkVec<CkArrayIndex> *l) : CkLocIterator() {
    list = l;
  }

  virtual void addLocation (CkLocation &loc) {
    list->push_back(loc.getIndex());
  }
};



// forward declaration of wrapper for ComlibManager::registerArrayListener
void ComlibManagerRegisterArrayListener(CkArrayID, ComlibArrayInfo*);

class CharmStrategy {
    
 protected:
  //int forwardOnMigration;
    ComlibLearner *learner;
    CmiBool mflag;    //Does this strategy handle point-to-point or 
    CkCallback onFinish;


    int deliverToIndices(void *msg, int numDestIdxs, const CkArrayIndex* indices );
    
    inline void deliverToIndices(void *msg, const CkVec< CkArrayIndex > &indices ){
      deliverToIndices(msg, indices.size(), indices.getVec() );
    }
    
    
 public:
    //int iterationNumber;
    ComlibGroupInfo ginfo;
    ComlibNodeGroupInfo nginfo;

    ComlibArrayInfo ainfo;
    
    CharmStrategy() { //: Strategy() {
      //setType(GROUP_STRATEGY); 
      //forwardOnMigration = 0;
      //iterationNumber = 0;
      learner = NULL;
      mflag = CmiFalse;
    }

    CharmStrategy(CkMigrateMessage *m) { //: Strategy(m){
      learner = NULL;
    }

    //Set flag to optimize strategy for 
    inline void setMulticast(){
        mflag = CmiTrue;
    }

    //get the multicast flag
    CmiBool getMulticast () {
        return mflag;
    }

    inline void setOnFinish (CkCallback of) {
      onFinish = of;
    }

    inline CkCallback getOnFinish () {
      return onFinish;
    }

    
    ComlibLearner *getLearner() {return learner;}
    void setLearner(ComlibLearner *l) {learner = l;}
    
    virtual void pup(PUP::er &p);
 
};

//API calls which will be valid when communication library is not linked
void ComlibNotifyMigrationDone();
//int ComlibGetLastKnown(CkArrayID aid, CkArrayIndex idx);


#endif

---