Home Research Papers Posters Manuals Talks Download People Help Internal

ck-core/register.h

Go to the documentation of this file.

#ifndef _REGISTER_H
#define _REGISTER_H

#include "charm.h"
#include "cklists.h"


class EntryInfo {
  public:
    CkCallFnPtr call;
    int msgIdx;
    int chareIdx;

    CkMarshallUnpackFn marshallUnpack;

#if CMK_CHARMDEBUG

    CkMessagePupFn messagePup;
#endif

    bool traceEnabled;
    bool noKeep;
    bool isImmediate;
    bool isInline;
    bool inCharm;
    bool appWork;
    bool ownsName; // if entry is templated or setName() is called, then free name in dtor
#ifdef ADAPT_SCHED_MEM
   bool isMemCritical;
#endif

    const char *name;

    EntryInfo(const char *n, CkCallFnPtr c, int m, int ci, bool ownsN=false) :
      call(c), msgIdx(m), chareIdx(ci),
      marshallUnpack(0)
#if CMK_CHARMDEBUG
      ,messagePup(0)
#endif
      ,traceEnabled(true), noKeep(false), isImmediate(false), isInline(false), inCharm(false), appWork(false),
      ownsName(ownsN), name(n)
    {
      if (ownsName) initName(n);
    }

    ~EntryInfo()
    {
      if (ownsName) delete [] name;
    }

    void setName(const char* new_name)
    {
      if (ownsName) delete [] name;
      initName(new_name);
    }

  private:
    // Should only be called from ctor or setName
    void initName(const char* new_name)
    {
      size_t len = strlen(new_name);
      // This is freed via the name pointer in the destructor
      char* temp = new char[len + 1];
      strcpy(temp, new_name);
      name = temp;
      ownsName = true;
    }
};

class MsgInfo {
  public:
    CkPackFnPtr pack;
    CkUnpackFnPtr unpack;
    CkDeallocFnPtr dealloc;
    size_t size;

    const char *name;

    MsgInfo(const char *n,CkPackFnPtr p,CkUnpackFnPtr u,CkDeallocFnPtr d,int s):
      pack(p), unpack(u), dealloc(d), size(s), name(n)
    {}
};

class ChareInfo {
  public:
    const char *name;
    size_t size;
    
    int defCtor,migCtor; 
    int numbases;
    int bases[16];
    
    ChareType  chareType;
    int mainChareIdx;

    int ndims;

    bool isIrr;

    bool inCharm;

    ChareInfo(const char *n, size_t s, ChareType t) : name(n), size(s) {
      defCtor=migCtor=-1;
      isIrr = false;
      numbases = 0;
      chareType = t;
      inCharm = false;
      mainChareIdx = -1;
      ndims = -1;
    }
    void setDefaultCtor(int idx) { defCtor = idx; }
    int getDefaultCtor(void) { return defCtor; }
    void setMigCtor(int idx) { migCtor = idx; }
    int getMigCtor(void) { return migCtor; }
    void addBase(int idx) {
      CkAssert(numbases+1 <= 16); // 'bases' is declared as an array of size 16 above,
                                  // but we could potentially make it a a std::vector
      bases[numbases++] = idx;
    }
    void setInCharm() { inCharm = true; }
    bool isInCharm() { return inCharm; }
    void setMainChareType(int idx) { mainChareIdx = idx; }
    int mainChareType() { return mainChareIdx; }
};

class MainInfo {
  public:
    void* obj; // real type is Chare*
    const char *name;
    int chareIdx;
    int entryIdx;
    int entryMigCtor;
    MainInfo(int c, int e) : name("main"), chareIdx(c), entryIdx(e) {}
    inline void* getObj(void) { return obj; }
    inline void setObj(void *_obj) { obj=_obj; }
};

class ReadonlyInfo {
  public:
    size_t size;
    void *ptr;
    CkPupReadonlyFnPtr pup;
    const char *name,*type;
    
    void pupData(PUP::er &p) {
      if (pup!=NULL)
        (pup)((void *)&p);
      else
        p((char *)ptr,size);
    }
    ReadonlyInfo(const char *n,const char *t,
     size_t s, void *p,CkPupReadonlyFnPtr pf)
    : size(s), ptr(p), pup(pf), name(n), type(t) {}
};

class ReadonlyMsgInfo {
  public:
    const char *name, *type;
    void **pMsg;
    ReadonlyMsgInfo(const char *n, const char *t,
    void **p) : name(n), type(t), pMsg(p) {}
};

template <class T>
class CkRegisteredInfo {
    CkVec<T *> vec;
    
    void outOfBounds(int idx) {
        const char *exampleName="";
        if (vec.size()>0) exampleName=vec[0]->name;
        CkPrintf("register.h> CkRegisteredInfo<%d,%s> called with invalid index "
            "%d (should be less than %d)\n", sizeof(T),exampleName,
            idx, vec.size());
        CkAbort("Registered idx is out of bounds-- is message or memory corrupted?");
    }
public:
    CkRegisteredInfo() :vec(CkSkipInitialization()) {}
        ~CkRegisteredInfo() {
            for (size_t i=0; i<vec.size(); i++) if (vec[i]) delete vec[i];
    } 

    int add(T *t) {
#if CMK_ERROR_CHECKING
        /* Make sure registrations only happen from rank 0: */
        if (CkMyRank()!=0)
            CkAbort("Can only do registrations from rank 0 processors");
#endif
        vec.push_back(t);
        return vec.size()-1;
    }
    
    size_t size(void) {return vec.size();}
    
    T *operator[](size_t idx) {
#if CMK_ERROR_CHECKING
        /* Bounds-check the index: */
        if (idx>=vec.size()) outOfBounds(idx);
#endif
        return vec[idx];
    }
};

extern CkRegisteredInfo<EntryInfo> _entryTable;
extern CkRegisteredInfo<MsgInfo> _msgTable;
extern CkRegisteredInfo<ChareInfo> _chareTable;
extern CkRegisteredInfo<MainInfo> _mainTable;
extern CkRegisteredInfo<ReadonlyInfo> _readonlyTable;
extern CkRegisteredInfo<ReadonlyMsgInfo> _readonlyMsgs;

extern void _registerInit(void);
extern void _registerDone(void);

extern int CkGetChareIdx(const char *name);

#endif

---