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