New version with migration and forwarding always working. The test program also works.
[charm.git] / src / ck-core / ComlibStrategy.h
1 #ifndef COMMLIBSTRATEGY_H
2 #define COMMLIBSTRATEGY_H
3
4 #include "charm++.h"
5 #include "convcomlibstrategy.h"
6
7 //Class managing Charm++ messages in the communication library.
8 //It is aware of envelopes, arrays, etc
9 class CharmMessageHolder : public MessageHolder{
10  public:
11     CkSectionID *sec_id;
12
13     CharmMessageHolder() : MessageHolder() {sec_id = NULL;}
14     CharmMessageHolder(CkMigrateMessage *m) : MessageHolder(m) {}
15     
16     CharmMessageHolder(char * msg, int dest_proc);
17     ~CharmMessageHolder();
18
19     char * getCharmMessage();
20     
21     virtual void pup(PUP::er &p);
22     PUPable_decl(CharmMessageHolder);
23 };
24
25 //Info classes that help bracketed streategies manage objects
26 //Each info class points to a list of source (or destination) objects
27 //ArrayInfo also access the array listener interface
28
29 class ComlibNodeGroupInfo {
30  protected:
31     CkNodeGroupID ngid;
32     int isNodeGroup;
33
34  public:
35     ComlibNodeGroupInfo();
36
37     void setSourceNodeGroup(CkNodeGroupID gid) {
38         ngid = gid;
39         isNodeGroup = 1;
40     }
41
42     int isSourceNodeGroup(){return isNodeGroup;}
43     CkNodeGroupID getSourceNodeGroup();
44
45     void pup(PUP::er &p);
46 };
47
48 class ComlibGroupInfo {
49  protected:
50     CkGroupID gid;
51     int *srcpelist, nsrcpes; //src processors for the elements
52     int isGroup;   
53
54  public:
55     ComlibGroupInfo();
56
57     void setSourceGroup(CkGroupID gid, int *srcpelist=0, int nsrcpes=0);
58     int isSourceGroup(){return isGroup;}
59     void getSourceGroup(CkGroupID &gid, int *&pelist, int &npes);
60     
61     void pup(PUP::er &p);
62 };
63
64 class ComlibMulticastMsg;
65
66 /* Array strategy helper class.
67    Stores the source and destination arrays.
68    Computes most recent processor maps of source and destinaton arrays.
69    
70    Array section helper functions, make use of sections easier for the
71    communication library.
72 */
73
74 class ComlibArrayInfo {
75  protected:
76     CkArrayID src_aid;
77     CkArrayIndexMax *src_elements; //src array elements
78     int nSrcIndices;              //number of source indices   
79     int isSrcArray;
80
81     CkArrayID dest_aid;
82     CkArrayIndexMax *dest_elements; //dest array elements
83     int nDestIndices;              //number of destintation indices   
84     int isDestArray;
85
86     CkVec<CkArrayIndexMax> localDestIndexVec;
87     
88  public:
89     ComlibArrayInfo();
90
91     void setSourceArray(CkArrayID aid, CkArrayIndexMax *e=0, int nind=0);
92     int isSourceArray(){return isSrcArray;}
93     void getSourceArray(CkArrayID &aid, CkArrayIndexMax *&e, int &nind);
94     
95     void setDestinationArray(CkArrayID aid, CkArrayIndexMax *e=0, int nind=0);
96     int isDestinationArray(){return isDestArray;}
97     void getDestinationArray(CkArrayID &aid, CkArrayIndexMax *&e, int &nind);
98
99     void localBroadcast(envelope *env);
100     static void localMulticast(CkVec<CkArrayIndexMax> *idx_vec,envelope *env);
101     static void deliver(envelope *env);
102
103     void getSourcePeList(int *&pelist, int &npes);
104     void getDestinationPeList(int *&pelist, int &npes);
105     void getCombinedPeList(int *&pelist, int &npes);
106     
107     void pup(PUP::er &p);
108 };
109
110
111 /* All Charm++ communication library strategies should inherit from
112    this strategy. They should specify their object domain by setting
113    Strategy::type. They have three helpers predefined for them for
114    node groups, groups and arrays */
115
116 class CharmStrategy : public Strategy {
117     int forwardOnMigration;
118
119  public:
120     ComlibGroupInfo ginfo;
121     ComlibNodeGroupInfo nginfo;
122
123     //The communication library array listener watches and monitors
124     //the array elements belonging to ainfo.src_aid
125     ComlibArrayInfo ainfo;
126     
127     CharmStrategy() : Strategy() {
128         setType(GROUP_STRATEGY); 
129         forwardOnMigration = 0;
130     }
131
132     CharmStrategy(CkMigrateMessage *m) : Strategy(m){}
133
134     //Called for each message
135     //Function inserts a Charm++ message
136     virtual void insertMessage(CharmMessageHolder *msg) {
137         CkAbort("Bummer Should Not come here:CharmStrategy is abstract\n");
138     }
139
140     //Removed the virtual!
141     //Charm strategies should not use Message Holder
142     void insertMessage(MessageHolder *msg);
143     
144     //Called after all chares and groups have finished depositing their 
145     //messages on that processor.
146     virtual void doneInserting() {}
147
148     //Added a new call that is called after the strategy had be
149     //created on every processor.
150     //DOES NOT exist in Converse Strategies
151     virtual void beginProcessing(int nelements){}
152
153     virtual void pup(PUP::er &p);
154     PUPable_decl(CharmStrategy);
155
156     void setForwardOnMigration(int f) {
157         forwardOnMigration = f;
158     }
159     
160     int getForwardOnMigration() {
161         return forwardOnMigration;
162     }
163 };
164
165 #endif