d9af80b5a9c4e77ee6bc805a24e1cca891c25d61
[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
21 #define CHARM_MPI 0 
22 #define MAX_NSTRAT 1024
23 #define LEARNING_PERIOD 1000 //Number of iterations after which the
24                              //learning framework will discover 
25                              //the appropriate strategy, not completely 
26                              //implemented
27 PUPbytes(comID);
28
29 #include "ComlibStats.h"
30
31 #include "comlib.decl.h"
32
33 //Dummy message to be sent incase there are no messages to send. 
34 //Used by only the EachToMany strategy!
35 class ComlibDummyMsg: public CMessage_ComlibDummyMsg {
36     int dummy;
37 };
38
39 /*
40 //Priority message to call end iteration
41 class PrioMsg: public CMessage_PrioMsg {
42  public:
43     int instID;
44 };
45 */
46
47 class ComlibMulticastMsg : public CkMcastBaseMsg, 
48                public CMessage_ComlibMulticastMsg {
49     
50   public:
51     int nIndices;
52     char *usrMsg;        
53     CkArrayIndexMax *indices;
54 };
55
56 class ComlibManager;
57
58 //An Instance of the communication library.
59 class ComlibInstanceHandle {
60  private:    
61     
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     void setForwardingOnMigration(){toForward = 1;} 
73     void init();
74     void beginIteration();
75     void endIteration();
76     
77     CkGroupID getComlibManagerID();
78     void setStrategy(CharmStrategy *);
79     CharmStrategy *getStrategy();        
80     int getSourcePe() {return _srcPe;}
81
82     void setSourcePe() {_srcPe = CkMyPe();}
83
84     friend class ComlibManager;
85     void pup(PUP::er &p) {
86         p | _instid;
87         p | _dmid;
88         p | _srcPe;
89         p | toForward;
90     }
91 };
92
93 class LBMigrateMsg;
94
95 class ComlibManager: public CkDelegateMgr {
96     friend class ComlibInstanceHandle;
97
98     int *bcast_pelist;  //Pelist passed to all broadcast operations
99
100     int section_send_event;
101
102     int remotePe;
103     CmiBool isRemote;
104     CmiBool strategyCreated;
105
106     int npes;
107     int *pelist;
108
109     CkArrayIndexMax dummyArrayIndex;
110
111     //For compatibility and easier use!
112     int strategyID; //Identifier of the strategy
113
114     //Pointer to the converse comm lib strategy table
115     StrategyTable *strategyTable;
116
117     CkQ<CharmStrategy *> ListOfStrategies; //temporary list of strategies
118     
119     CkQ<CharmMessageHolder *> remoteQ;  //list of remote messages
120                                         //after the object has
121                                         //migrated
122
123     //The number of strategies created by the user
124     //int nstrats; //now part of conv comlib
125     
126     int curStratID, prevStratID;      
127     //Number of strategies created by the user.
128
129     //flags
130     int receivedTable, flushTable, barrierReached, barrier2Reached;
131     CmiBool lbUpdateReceived;
132
133     int bcount , b2count;
134     //int totalMsgCount, totalBytes, nIterations;
135
136     ComlibArrayListener *alistener;
137     int prioEndIterationFlag;
138
139     ComlibGlobalStats clib_gstats; 
140     int    numStatsReceived;
141
142     int curComlibController;   //Processor where strategies are  recreated
143     int clibIteration;         //Number of such learning iterations,
144                                //each of which is triggered by a
145                                //loadbalancing operation
146
147     void init(); //initialization function
148
149     //charm_message for multicast for a section of that group
150     void multicast(CharmMessageHolder *cmsg); //charm message holder here
151     //void multicast(void *charm_msg, int npes, int *pelist);
152
153     //The following funtions can be accessed only from ComlibInstanceHandle
154     void beginIteration();     //Notify begining of a bracket with
155                                //strategy identifier
156
157     void endIteration();       //Notify end, endIteration must be
158                                //called if a beginIteration is
159                                //called. Otherwise end of the entry
160                                //method is assumed to be the end of
161                                //the bracket.
162     
163     void setInstance(int id); 
164
165     //void prioEndIteration(PrioMsg *pmsg);
166     void registerStrategy(int pos, CharmStrategy *s);
167
168  public:
169
170     ComlibLocalStats clib_stats;   //To store statistics of
171                                    //communication operations
172     
173     ComlibManager();  //Recommended constructor
174
175     ComlibManager(CkMigrateMessage *m) { }
176     int useDefCtor(void){ return 1; } //Use default constructor should
177     //be pupped and store all the strategies.
178     
179     void barrier(void);
180     void barrier2(void);
181     void resumeFromBarrier2(void);
182
183     //Receive table of strategies.
184     void receiveTable(StrategyWrapper &sw, 
185                       CkHashtableT <ClibGlobalArrayIndex, int>&); 
186
187     void ArraySend(CkDelegateData *pd,int ep, void *msg, 
188                    const CkArrayIndexMax &idx, CkArrayID a);
189
190     void receiveRemoteSend(CkQ<CharmMessageHolder*> &rq, int id);
191     void sendRemote();
192
193     void GroupSend(CkDelegateData *pd, int ep, void *msg, int onpe, 
194                    CkGroupID gid);
195     
196     virtual void ArrayBroadcast(CkDelegateData *pd,int ep,void *m,CkArrayID a);
197     virtual void GroupBroadcast(CkDelegateData *pd,int ep,void *m,CkGroupID g);
198     virtual void ArraySectionSend(CkDelegateData *pd, int ep ,void *m, 
199                                   CkArrayID a, CkSectionID &s);
200
201     CharmStrategy *getStrategy(int instid)
202         {return (CharmStrategy *)(* strategyTable)[instid].strategy;}
203
204     StrategyTableEntry *getStrategyTableEntry(int instid)
205         {return &((*strategyTable)[instid]);}
206
207     //To create a new strategy, returns handle to the strategy table;
208     ComlibInstanceHandle createInstance();  
209     void broadcastStrategies();             //Done creating instances
210
211     void AtSync();           //User program called loadbalancer
212     void lbUpdate(LBMigrateMsg *); //loadbalancing updates
213
214     //Learning functions
215     //void learnPattern(int totalMessageCount, int totalBytes);
216     //void switchStrategy(int strat);
217
218     void setRemote(int remotePe);
219
220     void collectStats(ComlibLocalStats &s, int src,CkVec<ClibGlobalArrayIndex>&);
221
222     //Returns the processor on which the comlib sees the array element
223     //belonging to
224     inline int getLastKnown(CkArrayID a, CkArrayIndexMax &idx) {
225         /*
226         ClibGlobalArrayIndex cidx;
227         cidx.aid = a;
228         cidx.idx = idx;
229         int pe = locationTable->get(cidx);
230
231         if(pe == 0) {
232             //Array element does not exist in the table
233
234             CkArray *array = CkArrayID::CkLocalBranch(a);
235             pe = array->lastKnown(idx) + CkNumPes();
236             locationTable->put(cidx) = pe;
237         }
238         //CkPrintf("last pe = %d \n", pe - CkNumPes());
239
240         return pe - CkNumPes();
241         */
242         return ComlibGetLastKnown(a, idx);
243     }
244 };
245
246 void ComlibDelegateProxy(CProxy *proxy);
247
248 ComlibInstanceHandle CkCreateComlibInstance();
249 ComlibInstanceHandle CkGetComlibInstance();
250 ComlibInstanceHandle CkGetComlibInstance(int id);
251 void ComlibResetSectionProxy(CProxySection_ArrayBase *sproxy);
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