Home Research Papers Posters Manuals Talks Download People Help Internal

libs/ck-libs/idxl/idxl_comm.h

Go to the documentation of this file.

#ifndef __CHARM_IDXL_COMM_H
#define __CHARM_IDXL_COMM_H

#include "pup.h"
#include "cklists.h"
#include "ckhashtable.h"
#include "charm.h"


class IDXL_Share {
 public:
  int chk; //Chunk we're shared with
  int idx; //Our index in the local comm. list for that chunk
  IDXL_Share(int x=0) {chk=idx=-1;}
  IDXL_Share(int c,int i) :chk(c), idx(i) {}
  void pup(PUP::er &p) {p(chk); p(idx);}
};
PUPmarshall(IDXL_Share)


class IDXL_Rec {
    int entity; //Index of entity (node or element) we describe
    CkVec<IDXL_Share> shares;
    int oldlength;
public:
    IDXL_Rec(int entity_=-1);
    ~IDXL_Rec();

    void pup(PUP::er &p);
    
    inline int getEntity(void) const {return entity;}
    inline int getShared(void) const {return shares.size();}
    inline int getChk(int shareNo) const {return shares[shareNo].chk;}
    inline int getIdx(int shareNo) const {return shares[shareNo].idx;}
    bool hasChk(int chk) const {
        for (int i=0;i<getShared();i++)
            if (getChk(i)==chk) return true;
        return false;
    }
    void add(int chk,int idx);
};

class IDXL_Map {
    CkHashtableT<CkHashtableAdaptorT<int>,IDXL_Rec *> map;
public:
    IDXL_Map();
    ~IDXL_Map();

    //Add a IDXL_Rec entry for this entity
    void add(int entity,int chk,int idx);
    
    //Look up this entity's IDXL_Rec.  Returns NULL if entity is not shared.
    const IDXL_Rec *get(int entity) const;
};

class IDXL_List {
    int chunk; //Global number of other chunk   
    CkVec<int> shared; //Local indices of shared entities
    bool lock;
public:
    IDXL_List();
    IDXL_List(int otherchunk);
    ~IDXL_List();
    int getDest(void) const {return chunk;}
    int size(void) const {return shared.size();}
    int &operator[](int idx) {return shared[idx]; }
    int operator[](int idx) const {return shared[idx]; }
    const int *getVec(void) const {return &shared[0];}
    bool lockIdxl();
    void unlockIdxl();
    bool isLocked();
    int push_back(int localIdx);
    bool set(int localIdx, int sharedIdx);
    bool unset(int sharedIdx);
    int exists(int localIdx);
    int get(int sharedIdx);
    void pup(PUP::er &p);
    void sort2d(double *coord);
    void sort3d(double *coord);
};
PUPmarshall(IDXL_List)




class IDXL_Print_Map {
public:
    virtual void map(int srcIdx) const =0;
};

class IDXL_Side : public CkNoncopyable {
    CkPupPtrVec<IDXL_List, CkPupAlwaysAllocatePtr<IDXL_List> > comm; 

    IDXL_Map *cached_map;
    IDXL_Map &getMap(void);
    
    //Return the Comm_List associated with this chunk, or NULL
    IDXL_List *getListN(int chunk) { 
        for (int i=0;i<comm.size();i++)
            if (comm[i]->getDest()==chunk)
                return comm[i];
        return NULL; 
    }
public:
    IDXL_Side(void);
    void pup(PUP::er &p);
    ~IDXL_Side();
    int total() const;
    
    int size(void) const {return comm.size();}
    const IDXL_List &getLocalList(int idx) const { return *comm[idx]; }
    IDXL_List &setLocalList(int idx) { return *comm[idx]; }
    
    int findLocalList(int chunk) const {
        for (int i=0;i<comm.size();i++) 
            if (comm[i]->getDest()==chunk)
                return i;
        return -1;
    }
    
    const IDXL_List &getList(int chunk) const { 
        const IDXL_List *ret=((IDXL_Side *)this)->getListN(chunk);
        if (ret==NULL) CkAbort("FEM> Communication lists corrupted (unexpected message)");
        return *ret; 
    }
    IDXL_List &addList(int chunk) {
        IDXL_List *ret=getListN(chunk);
        if (ret==NULL) { //Have to add a new list:
            ret=new IDXL_List(chunk);
            comm.push_back(ret);
        }
        return *ret;
    }

    IDXL_List *getIdxlListN(int chunk) {
      return getListN(chunk);
    }
    
    const IDXL_Rec *getRec(int entity) const;
    

    void flushMap(void);
    
    void add(int myChunk,int myLocalNo,
         int hisChunk,int hisLocalNo,IDXL_Side &hisList);
    
    
    void clear();
    
    /***
     * added by Nilesh, needs comments.
     * */
    bool lockIdxl(int sharedWithChk);
    void unlockIdxl(int sharedWithChk);
    bool isLocked(int sharedWithChk);
    int addNode(int localNo, int sharedWithChk);
    int removeNode(int localNo, int sharedWithChk);
    bool setNode(int localNo, int sharedWithChk, int sharedIdx);
    bool unsetNode(int sharedWithChk, int sharedIdx);
    int existsNode(int localNo, int sharedWithChk);
    int getNode(int sharedWithChk, int sharedIdx);

    void print(const IDXL_Print_Map *idxmap=NULL) const;

    void sort2d(double *coord);

    void sort3d(double *coord);
};

class IDXL : public CkNoncopyable {
    IDXL_Side *send,*recv;
    IDXL_Side *alloc_send, *alloc_recv;
public:
    IDXL(IDXL_Side *sendrecv) {
        send=sendrecv; recv=sendrecv;
        alloc_send=alloc_recv=NULL;
    }
    
    IDXL(IDXL_Side *send_, IDXL_Side *recv_) {
        send=send_; recv=recv_;
        alloc_send=alloc_recv=NULL;
    }
    
    IDXL(void) {
        send=alloc_send=NULL;
        recv=alloc_recv=NULL;
    }
    
    void allocateSingle(void) {
        send=alloc_send=new IDXL_Side;
        recv=send; alloc_recv=NULL;
    }
    void allocateDual(void) {
        send=alloc_send=new IDXL_Side;
        recv=alloc_recv=new IDXL_Side;
    }
    
    void pup(PUP::er &p) {
        int isSendRecv= (send==recv);
        p|isSendRecv;
        if (!send) send=alloc_send=new IDXL_Side;
        send->pup(p);
        if (isSendRecv) {
            recv=send;
        }
        else {
            if (!recv) recv=alloc_recv=new IDXL_Side;
            recv->pup(p);
        }
    }
    ~IDXL(void) {
        delete alloc_send; delete alloc_recv;
    }
    
    bool isSingle(void) const {return send==recv;}
    
    IDXL_Side &getSend(void) {return *send;}
    const IDXL_Side &getSend(void) const {return *send;}
    IDXL_Side &getRecv(void) {return *recv;}
    const IDXL_Side &getRecv(void) const {return *recv;}

    void sort2d(double *coord);

    void sort3d(double *coord);
};

#endif

---