Home Research Papers Posters Manuals Talks Download People Help Internal

ck-core/ckarrayoptions.h

Go to the documentation of this file.

#ifndef __CKARRAYOPTIONS_H
#define __CKARRAYOPTIONS_H

#include "ckarrayindex.h"
#include "ckmulticast.h"

/********************* CkArrayListener ****************/
class ArrayElement;
class CkArrayListener : public PUP::able {
  int nInts;       // Number of ints of data to store per element
  int dataOffset;  // Int offset of our data within the element
 public:
  CkArrayListener(int nInts_);
  CkArrayListener(CkMigrateMessage* m);
  virtual void pup(PUP::er& p);
  PUPable_abstract(CkArrayListener)

      
      virtual void ckRegister(CkArray* arrMgr, int dataOffset_);

  inline int ckGetLen(void) const { return nInts; }
  inline int ckGetOffset(void) const { return dataOffset; }
  inline int* ckGetData(ArrayElement* el) const;

  virtual void ckBeginInserting(void) {}
  virtual void ckEndInserting(void) {}

  // The stamp/creating/created/died sequence happens, in order, exactly
  // once per array element.  Migrations don't show up here.
  virtual void ckElementStamp(int* eltInfo) { (void)eltInfo; }
  virtual void ckElementCreating(ArrayElement* elt) { (void)elt; }
  virtual bool ckElementCreated(ArrayElement* elt) {
    (void)elt;
    return true;
  }

  virtual void ckElementDied(ArrayElement* elt) { (void)elt; }

  // The leaving/arriving seqeunce happens once per migration.
  virtual void ckElementLeaving(ArrayElement* elt) { (void)elt; }

  virtual bool ckElementArriving(ArrayElement* elt) {
    (void)elt;
    return true;
  }

  virtual void flushState() {}
};

/*********************** CkArrayOptions *******************************/
class CkArrayOptions {
  friend class CkArray;

  CkArrayIndex start, end, step;
  CkArrayIndex numInitial;  

  CkArrayIndex bounds;
  CkGroupID map;       
  CkGroupID locMgr;    
  CkGroupID mCastMgr;  
  CkPupAblePtrVec<CkArrayListener> arrayListeners;  // CkArrayListeners for this array
  CkCallback reductionClient;                       // Default target of reductions
  CkCallback initCallback; // Callback to be invoked after chare array creation is complete
  bool anytimeMigration;                            // Elements are allowed to move freely
  bool disableNotifyChildInRed;  // Child elements are not notified when reduction starts
  bool staticInsertion;          // Elements are only inserted at construction
  bool broadcastViaScheduler;    // broadcast inline or through scheduler
  bool sectionAutoDelegate;      // Create a mCastMgr and auto-delegate all sections

  void init();

  void updateIndices();
  void updateNumInitial();

 public:
  // Used by external world:
  CkArrayOptions(void);                         
  CkArrayOptions(int ndims, int dims[]);        
  CkArrayOptions(int ni1_);                     
  CkArrayOptions(int ni1_, int ni2_);           
  CkArrayOptions(int ni1_, int ni2_, int ni3);  
  CkArrayOptions(short ni1_, short ni2_, short ni3,
                 short ni4_);  
  CkArrayOptions(short ni1_, short ni2_, short ni3, short ni4_,
                 short ni5_);  
  CkArrayOptions(short ni1_, short ni2_, short ni3, short ni4_, short ni5_,
                 short ni6_);  
  CkArrayOptions(CkArrayIndex s, CkArrayIndex e,
                 CkArrayIndex step);  


  CkArrayOptions& setStart(CkArrayIndex s) {
    start = s;
    updateNumInitial();
    return *this;
  }
  CkArrayOptions& setEnd(CkArrayIndex e) {
    end = e;
    updateNumInitial();
    return *this;
  }
  CkArrayOptions& setStep(CkArrayIndex s) {
    step = s;
    updateNumInitial();
    return *this;
  }

  CkArrayOptions& setNumInitial(int ni) {
    numInitial = CkArrayIndex1D(ni);
    updateIndices();
    return *this;
  }
  CkArrayOptions& setNumInitial(int ni1, int ni2) {
    numInitial = CkArrayIndex2D(ni1, ni2);
    updateIndices();
    return *this;
  }
  CkArrayOptions& setNumInitial(int ni1, int ni2, int ni3) {
    numInitial = CkArrayIndex3D(ni1, ni2, ni3);
    updateIndices();
    return *this;
  }
  CkArrayOptions& setNumInitial(short ni1, short ni2, short ni3, short ni4) {
    numInitial = CkArrayIndex4D(ni1, ni2, ni3, ni4);
    updateIndices();
    return *this;
  }
  CkArrayOptions& setNumInitial(short ni1, short ni2, short ni3, short ni4, short ni5) {
    numInitial = CkArrayIndex5D(ni1, ni2, ni3, ni4, ni5);
    updateIndices();
    return *this;
  }
  CkArrayOptions& setNumInitial(short ni1, short ni2, short ni3, short ni4, short ni5,
                                short ni6) {
    numInitial = CkArrayIndex6D(ni1, ni2, ni3, ni4, ni5, ni6);
    updateIndices();
    return *this;
  }

  CkArrayOptions& setBounds(int ni) {
    bounds = CkArrayIndex1D(ni);
    return *this;
  }
  CkArrayOptions& setBounds(int ni1, int ni2) {
    bounds = CkArrayIndex2D(ni1, ni2);
    return *this;
  }
  CkArrayOptions& setBounds(int ni1, int ni2, int ni3) {
    bounds = CkArrayIndex3D(ni1, ni2, ni3);
    return *this;
  }
  CkArrayOptions& setBounds(short ni1, short ni2, short ni3, short ni4) {
    bounds = CkArrayIndex4D(ni1, ni2, ni3, ni4);
    return *this;
  }
  CkArrayOptions& setBounds(short ni1, short ni2, short ni3, short ni4, short ni5) {
    bounds = CkArrayIndex5D(ni1, ni2, ni3, ni4, ni5);
    return *this;
  }
  CkArrayOptions& setBounds(short ni1, short ni2, short ni3, short ni4, short ni5,
                            short ni6) {
    bounds = CkArrayIndex6D(ni1, ni2, ni3, ni4, ni5, ni6);
    return *this;
  }

  CkArrayOptions& setMap(const CkGroupID& m) {
    map = m;
    return *this;
  }

  CkArrayOptions& bindTo(const CkArrayID& b);

  CkArrayOptions& setLocationManager(const CkGroupID& l) {
    locMgr = l;
    return *this;
  }

  CkArrayOptions& setMcastManager(const CkGroupID& m) {
    mCastMgr = m;
    return *this;
  }

  CkArrayOptions& addListener(CkArrayListener* listener);

  CkArrayOptions& setAnytimeMigration(bool b) {
    anytimeMigration = b;
    return *this;
  }
  CkArrayOptions& setStaticInsertion(bool b);
  CkArrayOptions& setBroadcastViaScheduler(bool b) {
    broadcastViaScheduler = b;
    return *this;
  }
  CkArrayOptions& setSectionAutoDelegate(bool b) {
    sectionAutoDelegate = b;
    return *this;
  }
  CkArrayOptions& setReductionClient(CkCallback cb) {
    reductionClient = cb;
    return *this;
  }
  CkArrayOptions &setInitCallback(CkCallback cb) {
    initCallback = cb;
    return *this;
  }

  // Used by the array manager:
  const CkArrayIndex& getStart(void) const { return start; }
  const CkArrayIndex& getEnd(void) const { return end; }
  const CkArrayIndex& getStep(void) const { return step; }
  const CkArrayIndex& getNumInitial(void) const { return numInitial; }
  const CkArrayIndex& getBounds(void) const { return bounds; }
  const CkGroupID& getMap(void) const { return map; }
  const CkGroupID& getLocationManager(void) const { return locMgr; }
  const CkGroupID& getMcastManager(void) const { return mCastMgr; }
  bool isSectionAutoDelegated(void) const { return sectionAutoDelegate; }
  const CkCallback &getInitCallback(void) const {return initCallback;}
  int getListeners(void) const { return arrayListeners.size(); }
  CkArrayListener* getListener(int listenerNum) {
    CkArrayListener* ret = arrayListeners[listenerNum];
    arrayListeners[listenerNum] = NULL;  // Don't throw away this listener
    return ret;
  }

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

#endif

---