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