a few doxygen documentation
[charm.git] / src / ck-com / ComlibManager.h
1 #ifndef COMMLIBMANAGER_H
2 #define COMMLIBMANAGER_H
3
4 /**
5    @defgroup Comlib  Charm++ Communication Optimization Framework 
6 */
7 /*@{*/
8
9 #include "charm++.h"
10 #include "cksection.h"
11 #include "envelope.h"
12 #include "convcomlib.h"
13 #include <math.h>
14
15 #include "charm++.h"
16 #include "convcomlibmanager.h"
17
18 #define CHARM_MPI 0 
19 #define MAX_NSTRAT 1024
20 #define LEARNING_PERIOD 1000 //Number of iterations after which the
21                              //learning framework will discover 
22                              //the appropriate strategy, not completely 
23                              //implemented
24 PUPbytes(comID);
25
26 #include "ComlibStats.h"
27
28 #include "comlib.decl.h"
29
30 ///Dummy message to be sent in case there are no messages to send. 
31 ///Used by only the EachToMany strategy!
32 class ComlibDummyMsg: public CMessage_ComlibDummyMsg {
33     int dummy;
34 };
35
36 /*
37 //Priority message to call end iteration
38 class PrioMsg: public CMessage_PrioMsg {
39  public:
40     int instID;
41 };
42 */
43
44 /**
45  * Structure used to hold a count of the indeces associated to each pe in a multicast message.
46  */
47 struct ComlibMulticastIndexCount {
48   int pe;
49   int count;
50 };
51
52 ///for use of qsort
53 inline int indexCountCompare(const void *a, const void *b) {
54   ComlibMulticastIndexCount a1 = *(ComlibMulticastIndexCount*) a;
55   ComlibMulticastIndexCount b1 = *(ComlibMulticastIndexCount*) b;
56
57   if(a1.pe < b1.pe)
58     return -1;
59   
60   if(a1.pe == b1.pe)
61     return 0;
62   
63   if(a1.pe > b1.pe)
64     return 1;
65   
66   return 0;
67 }
68
69 class ComlibMulticastMsg : public CkMcastBaseMsg, 
70                public CMessage_ComlibMulticastMsg {
71     
72   public:
73     int nPes;
74     ComlibMulticastIndexCount *indicesCount;
75     CkArrayIndexMax *indices;
76     char *usrMsg;        
77 };
78
79 class ComlibManager;
80
81 /** An Instance of the communication library. It can be seen as the proxy given
82     by ComlibManager upon registration of a strategy to the framework.
83  */
84 class ComlibInstanceHandle : public CkDelegateData {
85  private:    
86     int _instid;
87     CkGroupID _dmid;
88     int _srcPe;
89     int toForward;
90
91  public:
92     ComlibInstanceHandle();
93     ComlibInstanceHandle(const ComlibInstanceHandle &h);
94     ComlibInstanceHandle(int instid, CkGroupID dmid);    
95    
96     ComlibInstanceHandle &operator=(const ComlibInstanceHandle &h);
97
98     void setForwardingOnMigration(){toForward = 1;} 
99     void beginIteration();
100     void endIteration();
101     
102     CkGroupID getComlibManagerID();
103     void setStrategy(CharmStrategy *);
104     CharmStrategy *getStrategy();        
105     int getSourcePe() {return _srcPe;}
106
107     void setSourcePe() {_srcPe = CkMyPe();}
108
109     friend class ComlibManager;
110     void pup(PUP::er &p) {
111
112         if(p.isUnpacking())
113              reset();        
114
115         p | _instid;
116         p | _dmid;
117         p | _srcPe;
118         p | toForward;
119     }
120 };
121
122 class LBMigrateMsg;
123
124 /** The main group doing the management of all the system. It takes care of
125     holding all the registered strategies, calling them when a message arrives,
126     and modifying them when needed by the learning framework. It installed
127     itself as a delegated class from CkDelegateMgr, overwriting the standard
128     path of message sending in charm.
129  */
130 class ComlibManager: public CkDelegateMgr {
131     friend class ComlibInstanceHandle;
132
133     int *bcast_pelist;  //Pelist passed to all broadcast operations
134
135     int section_send_event;
136
137     int remotePe;
138     CmiBool isRemote;
139     CmiBool strategyCreated;
140
141     int npes;
142     int *pelist;
143
144     CkArrayIndexMax dummyArrayIndex;
145
146     //For compatibility and easier use!
147     int strategyID; //<Identifier of the strategy
148
149     ///Pointer to the converse comm lib strategy table
150     StrategyTable *strategyTable;
151
152     CkQ<CharmStrategy *> ListOfStrategies; //temporary list of strategies
153     
154     CkQ<CharmMessageHolder *> remoteQ;  //list of remote messages
155                                         //after the object has
156                                         //migrated
157
158     //The number of strategies created by the user
159     //int nstrats; //now part of conv comlib
160     
161     int curStratID, prevStratID;      
162     //Number of strategies created by the user.
163
164     //flags
165     int receivedTable, setupComplete, barrierReached, barrier2Reached;
166     CmiBool lbUpdateReceived;
167
168     int bcount , b2count;
169     //int totalMsgCount, totalBytes, nIterations;
170
171     ComlibArrayListener *alistener;
172     int prioEndIterationFlag;
173
174     ComlibGlobalStats clib_gstats; 
175     int    numStatsReceived;
176
177     int curComlibController;   //Processor where strategies are  recreated
178     int clibIteration;         //Number of such learning iterations,
179                                //each of which is triggered by a
180                                //loadbalancing operation
181
182     void init(); ///Initialization function
183
184     //charm_message for multicast for a section of that group
185     void multicast(CharmMessageHolder *cmsg); //charm message holder here
186     //void multicast(void *charm_msg, int npes, int *pelist);
187
188     //The following funtions can be accessed only from ComlibInstanceHandle
189     void beginIteration();     ///Notify begining of a bracket with
190                                ///strategy identifier
191
192     void endIteration();       ///Notify end, endIteration must be
193                                ///called if a beginIteration is
194                                ///called. Otherwise end of the entry
195                                ///method is assumed to be the end of
196                                ///the bracket.
197     
198     void setInstance(int id); 
199
200     //void prioEndIteration(PrioMsg *pmsg);
201     void registerStrategy(int pos, CharmStrategy *s);
202
203  public:
204
205     ComlibLocalStats clib_stats;   //To store statistics of
206                                    //communication operations
207     
208     ComlibManager();  //Recommended constructor
209
210     ComlibManager(CkMigrateMessage *m) { }
211     int useDefCtor(void){ return 1; } //Use default constructor should
212     //be pupped and store all the strategies.
213     
214     void barrier(void);
215     void barrier2(void);
216     void resumeFromBarrier2(void);
217
218     //Receive table of strategies.
219     void receiveTable(StrategyWrapper &sw, 
220                       CkHashtableT <ClibGlobalArrayIndex, int>&); 
221
222     void ArraySend(CkDelegateData *pd,int ep, void *msg, 
223                    const CkArrayIndexMax &idx, CkArrayID a);
224
225     void receiveRemoteSend(CkQ<CharmMessageHolder*> &rq, int id);
226     void sendRemote();
227
228     void GroupSend(CkDelegateData *pd, int ep, void *msg, int onpe, 
229                    CkGroupID gid);
230     
231     virtual void ArrayBroadcast(CkDelegateData *pd,int ep,void *m,CkArrayID a);
232     virtual void GroupBroadcast(CkDelegateData *pd,int ep,void *m,CkGroupID g);
233     virtual void ArraySectionSend(CkDelegateData *pd, int ep ,void *m, 
234                                   CkArrayID a, CkSectionID &s, int opts);
235
236     CharmStrategy *getStrategy(int instid)
237         {return (CharmStrategy *)(* strategyTable)[instid].strategy;}
238
239     StrategyTableEntry *getStrategyTableEntry(int instid)
240         {return &((*strategyTable)[instid]);}
241
242     //To create a new strategy, returns handle to the strategy table;
243     ComlibInstanceHandle createInstance();  
244     void broadcastStrategies();             //Done creating instances
245
246     void AtSync();           //User program called loadbalancer
247     void lbUpdate(LBMigrateMsg *); //loadbalancing updates
248
249     //Learning functions
250     //void learnPattern(int totalMessageCount, int totalBytes);
251     //void switchStrategy(int strat);
252
253     void setRemote(int remotePe);
254
255     void collectStats(ComlibLocalStats &s, int src,CkVec<ClibGlobalArrayIndex>&);
256
257     //Returns the processor on which the comlib sees the array element
258     //belonging to
259     inline int getLastKnown(CkArrayID a, CkArrayIndexMax &idx) {
260         return ComlibGetLastKnown(a, idx);
261     }
262
263     CkDelegateData* ckCopyDelegateData(CkDelegateData *data); 
264     CkDelegateData *DelegatePointerPup(PUP::er &p,CkDelegateData *pd);
265 };
266
267 void ComlibDelegateProxy(CProxy *proxy);
268 void ComlibAssociateProxy(ComlibInstanceHandle *cinst, CProxy &proxy);
269 void ComlibAssociateProxy(CharmStrategy *strat, CProxy &proxy); 
270 ComlibInstanceHandle ComlibRegister(CharmStrategy *strat);
271 void ComlibBegin(CProxy &proxy);    
272 void ComlibEnd(CProxy &proxy);    
273
274 ComlibInstanceHandle CkCreateComlibInstance();
275 ComlibInstanceHandle CkGetComlibInstance();
276 ComlibInstanceHandle CkGetComlibInstance(int id);
277
278 void ComlibResetSectionProxy(CProxySection_ArrayBase *sproxy);
279
280 inline void ComlibResetProxy(CProxy *aproxy) {
281   ComlibInstanceHandle *handle = 
282     (ComlibInstanceHandle *) aproxy->ckDelegatedPtr();
283   handle->setSourcePe();
284 }
285
286 //Only Called when the strategies are not being created in main::main
287 void ComlibDoneCreating(); 
288
289 void ComlibInitSectionID(CkSectionID &sid);
290
291 void ComlibAtSync(void *msg);
292 void ComlibNotifyMigrationDoneHandler(void *msg);
293 void ComlibLBMigrationUpdate(LBMigrateMsg *);
294
295 #define RECORD_SEND_STATS(sid, bytes, dest) {             \
296         CProxy_ComlibManager cgproxy(CkpvAccess(cmgrID));               \
297         cgproxy.ckLocalBranch()->clib_stats.recordSend(sid, bytes, dest); \
298 }\
299
300 #define RECORD_RECV_STATS(sid, bytes, src) { \
301         CProxy_ComlibManager cgproxy(CkpvAccess(cmgrID)); \
302         cgproxy.ckLocalBranch()->clib_stats.recordRecv(sid, bytes, src); \
303 }\
304
305 #define RECORD_SENDM_STATS(sid, bytes, dest_arr, ndest) {       \
306         CProxy_ComlibManager cgproxy(CkpvAccess(cmgrID)); \
307         cgproxy.ckLocalBranch()->clib_stats.recordSendM(sid, bytes, dest_arr, ndest); \
308 }\
309
310 #define RECORD_RECVM_STATS(sid, bytes, src_arr, nsrc) {        \
311         CProxy_ComlibManager cgproxy(CkpvAccess(cmgrID)); \
312         cgproxy.ckLocalBranch()->clib_stats.recordRecvM(sid, bytes, src_arr, nsrc); \
313 }\
314
315 /*@}*/
316
317 #endif