Cleaned up Mesh Streaming strategy. Also added some more optimizations to MesgPacker
[charm.git] / src / ck-com / ComlibStrategy.h
1 #ifndef COMMLIBSTRATEGY_H
2 #define COMMLIBSTRATEGY_H
3
4 #include "charm++.h"
5 #include "ckhashtable.h"
6 #include "convcomlibstrategy.h"
7 #include "ComlibLearner.h"
8 #include "envelope.h"
9
10 CkpvExtern(int, migrationDoneHandlerID);
11
12 //Class managing Charm++ messages in the communication library.
13 //It is aware of envelopes, arrays, etc
14 class CharmMessageHolder : public MessageHolder{
15  public:
16     CkSectionID *sec_id;
17
18     CharmMessageHolder() : MessageHolder() {sec_id = NULL;}
19     CharmMessageHolder(CkMigrateMessage *m) : MessageHolder(m) {}
20     
21     CharmMessageHolder(char * msg, int dest_proc);
22     ~CharmMessageHolder();
23
24     inline char * getCharmMessage() {
25         return (char *)EnvToUsr((envelope *) data);
26     }
27     
28     virtual void pup(PUP::er &p);
29     PUPable_decl(CharmMessageHolder);
30 };
31
32
33 //Struct to store the comlib location table info
34 struct ClibGlobalArrayIndex {
35     CkArrayID aid;
36     CkArrayIndexMax idx;
37
38     //These routines allow ClibGlobalArrayIndex to be used in
39     //  a CkHashtableT
40     CkHashCode hash(void) const;
41     static CkHashCode staticHash(const void *a,size_t);
42     int compare(const ClibGlobalArrayIndex &ind) const;
43     static int staticCompare(const void *a,const void *b,size_t);
44 };
45 PUPbytes(ClibGlobalArrayIndex);
46
47 /*********** CkHashTable functions ******************/
48 inline CkHashCode ClibGlobalArrayIndex::hash(void) const
49 {
50     register CkHashCode ret = idx.hash() | (CkGroupID(aid).idx << 16);
51     return ret;
52 }
53
54 inline int ClibGlobalArrayIndex::compare(const ClibGlobalArrayIndex &k2) const
55 {
56     if(idx == k2.idx && aid == k2.aid)
57         return 1;
58     
59     return 0;
60 }
61
62 //ClibGlobalArrayIndex CODE
63 inline int ClibGlobalArrayIndex::staticCompare(const void *k1, const void *k2, 
64                                                 size_t ){
65     return ((const ClibGlobalArrayIndex *)k1)->
66                 compare(*(const ClibGlobalArrayIndex *)k2);
67 }
68
69 inline CkHashCode ClibGlobalArrayIndex::staticHash(const void *v,size_t){
70     return ((const ClibGlobalArrayIndex *)v)->hash();
71 }
72
73
74 typedef CkHashtableT<ClibGlobalArrayIndex,int> ClibLocationTableType;
75     
76 //Stores the location of many array elements used by the
77 //strategies.  Since hash table returns a reference to the object
78 //and for an int that will be 0, the actual value stored is pe +
79 //CkNumPes so 0 would mean processor -CkNumPes which is invalid.
80 CkpvExtern(ClibLocationTableType *, locationTable);
81
82 //Info classes that help bracketed streategies manage objects
83 //Each info class points to a list of source (or destination) objects
84 //ArrayInfo also access the array listener interface
85
86 class ComlibNodeGroupInfo {
87  protected:
88     CkNodeGroupID ngid;
89     int isNodeGroup;
90
91  public:
92     ComlibNodeGroupInfo();
93
94     void setSourceNodeGroup(CkNodeGroupID gid) {
95         ngid = gid;
96         isNodeGroup = 1;
97     }
98
99     int isSourceNodeGroup(){return isNodeGroup;}
100     CkNodeGroupID getSourceNodeGroup();
101
102     void pup(PUP::er &p);
103 };
104
105 class ComlibGroupInfo {
106  protected:
107     CkGroupID sgid, dgid;
108     int *srcpelist, nsrcpes; //src processors for the elements
109     int *destpelist, ndestpes;
110     int isSrcGroup;   
111     int isDestGroup;
112
113  public:
114     ComlibGroupInfo();
115     ~ComlibGroupInfo();
116
117     int isSourceGroup(){return isSrcGroup;}
118     int isDestinationGroup(){return isDestGroup;}
119
120     void setSourceGroup(CkGroupID gid, int *srcpelist=0, int nsrcpes=0);    
121     void getSourceGroup(CkGroupID &gid);
122     void getSourceGroup(CkGroupID &gid, int *&pelist, int &npes);
123
124     void setDestinationGroup(CkGroupID sgid,int *destpelist=0,int ndestpes=0);
125     void getDestinationGroup(CkGroupID &gid);
126     void getDestinationGroup(CkGroupID &dgid,int *&destpelist, int &ndestpes);
127
128     void getCombinedPeList(int *&pelist, int &npes);
129     void pup(PUP::er &p);
130 };
131
132 class ComlibMulticastMsg;
133
134 /* Array strategy helper class.
135    Stores the source and destination arrays.
136    Computes most recent processor maps of source and destinaton arrays.
137    
138    Array section helper functions, make use of sections easier for the
139    communication library.
140 */
141
142 class ComlibArrayInfo {
143  protected:
144     CkArrayID src_aid;
145     CkArrayIndexMax *src_elements; //src array elements
146     int nSrcIndices;              //number of source indices   
147     int isSrcArray;
148
149     CkArrayID dest_aid;
150     CkArrayIndexMax *dest_elements; //dest array elements
151     int nDestIndices;              //number of destintation indices   
152     int isDestArray;
153
154     CkVec<CkArrayIndexMax> localDestIndexVec;
155     
156  public:
157     ComlibArrayInfo();
158     ~ComlibArrayInfo();
159
160     void setSourceArray(CkArrayID aid, CkArrayIndexMax *e=0, int nind=0);
161     int isSourceArray(){return isSrcArray;}
162     void getSourceArray(CkArrayID &aid, CkArrayIndexMax *&e, int &nind);
163     
164     void setDestinationArray(CkArrayID aid, CkArrayIndexMax *e=0, int nind=0);
165     int isDestinationArray(){return isDestArray;}
166     void getDestinationArray(CkArrayID &aid, CkArrayIndexMax *&e, int &nind);
167
168     void localBroadcast(envelope *env);
169     static void localMulticast(CkVec<CkArrayIndexMax> *idx_vec,envelope *env);
170     static void deliver(envelope *env);
171
172     void getSourcePeList(int *&pelist, int &npes);
173     void getDestinationPeList(int *&pelist, int &npes);
174     void getCombinedPeList(int *&pelist, int &npes);
175     
176     void pup(PUP::er &p);
177 };
178
179
180 /* All Charm++ communication library strategies should inherit from
181    this strategy. They should specify their object domain by setting
182    Strategy::type. They have three helpers predefined for them for
183    node groups, groups and arrays */
184
185 class CharmStrategy : public Strategy {
186  protected:
187     int forwardOnMigration;
188     ComlibLearner *learner;
189
190  public:
191     ComlibGroupInfo ginfo;
192     ComlibNodeGroupInfo nginfo;
193
194     //The communication library array listener watches and monitors
195     //the array elements belonging to ainfo.src_aid
196     ComlibArrayInfo ainfo;
197     
198     CharmStrategy() : Strategy() {
199         setType(GROUP_STRATEGY); 
200         forwardOnMigration = 0;
201         learner = NULL;
202     }
203
204     CharmStrategy(CkMigrateMessage *m) : Strategy(m){
205         learner = NULL;
206     }
207
208     //Called for each message
209     //Function inserts a Charm++ message
210     virtual void insertMessage(CharmMessageHolder *msg) {
211       CkAbort("Bummer Should Not come here:CharmStrategy is abstract\n");
212     }
213
214     //Removed the virtual!
215     //Charm strategies should not use Message Holder
216     void insertMessage(MessageHolder *msg);
217     
218     //Called after all chares and groups have finished depositing their 
219     //messages on that processor.
220     // DUPLICATED virtual void doneInserting() {}
221
222     //Added a new call that is called after the strategy had be
223     //created on every processor.
224     //DOES NOT exist in Converse Strategies
225     virtual void beginProcessing(int nelements){}
226
227     //Added a new call that is called after the strategy had be
228     //created on every processor.  DOES NOT exist in Converse
229     //Strategies. Called when the strategy is deactivated, possibly as
230     //a result of a learning decision
231     virtual void finalizeProcessing(){}
232
233     virtual ComlibLearner *getLearner() {return learner;}
234     virtual void setLearner(ComlibLearner *l) {learner = l;}
235
236     virtual void pup(PUP::er &p);
237     PUPable_decl(CharmStrategy);
238
239     void setForwardOnMigration(int f) {
240         forwardOnMigration = f;
241     }
242     
243     int getForwardOnMigration() {
244         return forwardOnMigration;
245     }
246 };
247
248 //API calls which will be valid when communication library is not linked
249 int ComlibGetLastKnown(CkArrayID a, CkArrayIndexMax idx);
250 void ComlibNotifyMigrationDone();
251
252 #endif