Home Research Papers Posters Manuals Talks Download People Help Internal

conv-com/convcomlibstrategy.h

Go to the documentation of this file.

#ifndef CONVCOMLIBSTRATEGY_H
#define CONVCOMLIBSTRATEGY_H

#if 0
// FILIPPO: TEMPORARY HACK
#ifndef COMLIBSTRATEGY_H
#undef CkpvDeclare
#undef CkpvAccess
#undef CkpvExtern
#undef CkpvInitialize
#undef CkpvInitialized
#define CkpvDeclare CpvDeclare
#define CkpvAccess CpvAccess
#define CkpvExtern CpvExtern
#define CkpvInitialize CpvInitialize
#define CkpvInitialized CpvInitialized
#define CkMyPe CmiMyPe
#define CkNumPes CmiNumPes
#undef CkRegisterHandler
#define CkRegisterHandler(x) CmiRegisterHandler(x)
#endif
#endif




#include "converse.h"
#include "pup.h"
#include "cklists.h"
#include <set>

/***************************************************************
 * Definitions used by the strategies as constants plus information to
 * debug comlib.
 * Copied from old convcomlib.h - Filippo
 ****************************************************************/
extern int com_debug;
#ifdef CMK_OPTIMIZE
inline void ComlibPrintf(...) {}
#else
#define ComlibPrintf if(com_debug) CmiPrintf
//#define ComlibPrintf  CmiPrintf
#endif

#define USE_TREE 1            //Organizes the all to all as a tree
#define USE_MESH 2            //Virtual topology is a mesh here
#define USE_HYPERCUBE 3       //Virtual topology is a hypercube
#define USE_DIRECT 4          //A dummy strategy that directly forwards 
                              //messages without any processing.
#define USE_GRID 5            //Virtual topology is a 3d grid
#define USE_LINEAR 6          //Virtual topology is a linear array
#define USE_PREFIX 7          //Prefix router to avoid contention

#define IS_BROADCAST -1
#define IS_SECTION_MULTICAST -2

typedef int ComlibInstanceHandle;


class MessageHolder : public PUP::able {
 public:
    char *data;
    int size;
    int isDummy;
    
    //For multicast, the user can pass the pelist and list of Pes he
    //wants to send the data to.

    int npes;
    union {
      int *pelist;
      int dest_proc;
    };
    
    MessageHolder() 
        {dest_proc = size = isDummy = 0; data = NULL;}    

    MessageHolder(CkMigrateMessage *m) {}

    inline MessageHolder(char * msg, int sz, int proc) {
        data = msg;
        size = sz;

        npes = 1;
        dest_proc = proc;
        
        isDummy = 0;
    }

    inline MessageHolder(char * msg, int sz) {
        data = msg;
        size = sz;

        npes = 0;
        dest_proc = 0;
        
        isDummy = 0;
    }

    inline MessageHolder(char * msg, int sz, int np, int *pes) {
        data = msg;
        size = sz;

        npes = np;
        pelist = pes;
        
        isDummy = 0;
    }

    inline ~MessageHolder() {
        /*
          if(pelist != NULL && npes > 0)
          delete[] pelist;
        */
    }

    inline char * getMessage() {
        return data;
    }

    inline int getSize() {
      return size;
    }

    inline void * operator new(size_t size) {
        return CmiAlloc(size);
    }

    inline void operator delete (void *buf) {
        CmiFree(buf);
    }

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

// These should not be here by in Charm!!
#define CONVERSE_STRATEGY 0     //The strategy works for converse programs
#define NODEGROUP_STRATEGY 1    //Node group level optimizations 
#define GROUP_STRATEGY 2        //Charm Processor level optimizations
#define ARRAY_STRATEGY 3        //Array level optimizations

class Strategy : public PUP::able {
 protected:


    short type;
    short isStrategyBracketed;
    //int myInstanceID; DEPRECATED in favor of myHandle / A handle used by the
    //user to identify this strategy. This is a wrapper to the real handle which
    //is virtual.
    ComlibInstanceHandle myHandle;
    /* Used for pure converse strategies which need to deliver their message
        directly to a converse handler (and not to higher languages). This will
        be used as final deliverer. */
    // DEPRECATED! The destination should be read from the header of the envelope
    //int destinationHandler;

    inline int getInstance() {return myHandle;}

 public:
    Strategy();
    Strategy(CkMigrateMessage *m) : PUP::able(m) {
      // By default assume that the class is self contained, if a higher
      // language class desires, it can change the following two fields.
      //converseStrategy = this;
      //higherLevel = this;
    }

    // Is the knowledge of bracketized necessary? Currently it is used only to
    // register the strategy to the ComlibArrayListener...
    inline void setBracketed(){isStrategyBracketed = 1;}
    inline int isBracketed(){return isStrategyBracketed;}

    //virtual void bracketedCountingError() {}

    virtual void bracketedUpdatePeKnowledge(int *count) {}

    virtual void insertMessage(MessageHolder *msg)=0;// {}
    
    virtual void doneInserting() {}

    //inline void setInstance(int instid){myInstanceID = instid;}
    //inline int getInstance(){return myInstanceID;}

    inline int getType() {return type;}
    // TO DEPRECATE! we shouldn't change the type after creation
    inline void setType(int t) {type = t;}

    ComlibInstanceHandle getHandle() {return myHandle;}

    virtual void handleMessage(void *msg)=0;// {}
    
    virtual void deliver(char* msg, int size) {
      CmiAbort("Strategy::deliverer: If used, should be first redefined\n");
    };

    virtual void notifyDone() {}

    virtual void finalizeCreation() {}

    virtual void pup(PUP::er &p);
    //PUPable_decl(Strategy);
    PUPable_abstract(Strategy);
};

class StrategyWrapper {
 public:
  Strategy **strategy;
  int *position;
  CmiBool *replace;
  int nstrats;
  //int total_nstrats;

  StrategyWrapper() : nstrats(0), position(NULL), strategy(NULL) {}
  StrategyWrapper(int count);
  ~StrategyWrapper();
  void pup(PUP::er &p);
};



enum CountingErrorMode { NORMAL_MODE = 0, 
                         ERROR_MODE = 1, 
                         CONFIRM_MODE = 2,   
                         ERROR_FIXED_MODE = 3  };


enum CountingServerErrorMode { NORMAL_MODE_SERVER, 
                               ERROR_MODE_SERVER,
                               CONFIRM_MODE_SERVER,  
                               ERROR_FIXED_MODE_SERVER,
                               NON_SERVER_MODE_SERVER    };


enum DiscoveryErrorMode { NORMAL_DISCOVERY_MODE = 200, 
                          STARTED_DISCOVERY_MODE = 201, 
                          FINISHED_DISCOVERY_MODE = 202   };

class StrategyTableEntry {
public:
  Strategy *strategy;

  int isReady;
  int isNew;
  int isInSync;

  
  int bufferOutgoing;
  
  
  int bracketedSetupFinished;

  CkQ<MessageHolder*> tmplist;

  int numBufferReleaseReady;
  
  int numElements;   //< Count how many src(?) elements reside here

  //    Used to ensure strategies work in presence of migration
  int nBeginItr;     //< #elements that called begin iteration
  int nEndItr;       //< #elements that called end iteration
  int call_doneInserting; //< All elements deposited their data


  int lastKnownIteration;

  // values used during bracketed error/confirm mode
  int nEndSaved;        //< during error mode, number sent to processor 0
  int totalEndCounted;  //< on processor 0, total amount of endIterations counted
  int nProcSync;         //< on processor 0, number of processors already in the count

  // values used during the discovery process to count the number of objects
  // valid only on processor 0

  int *peList;
  
  
  int peConfirmCounter;
  int total; 
 
  
  void reset();
  


  StrategyTableEntry();



 private:
  CountingErrorMode errorMode;
  
  CountingServerErrorMode errorModeServer;
  
  
  DiscoveryErrorMode discoveryMode;


 public:

  CountingErrorMode getErrorMode(){return errorMode;}
  CountingServerErrorMode getErrorModeServer(){return errorModeServer;}
  DiscoveryErrorMode getDiscoveryMode(){return discoveryMode;}
   
  void setErrorMode(CountingErrorMode mode){
    errorMode=mode;
    ComlibPrintf("[%d] %s\n", CmiMyPe(), errorModeString());
  }
 
  void setErrorModeServer(CountingServerErrorMode mode){
    errorModeServer=mode;
    ComlibPrintf("[%d] %s lastKnownIteration=%d\n", CmiMyPe(), errorModeServerString(), lastKnownIteration);
  }
 
  void setDiscoveryMode(DiscoveryErrorMode mode){
    discoveryMode=mode;
    ComlibPrintf("[%d] %s\n", CmiMyPe(), discoveryModeString());
  }

  const char *errorModeString();
  const char *errorModeServerString();
  const char *discoveryModeString();  

};

typedef CkVec<StrategyTableEntry> StrategyTable;


#endif

---