f0792b7c8ca03e208656722246ab7b0e41fb2710
[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 /**
49  * Structure used to hold a count of the indeces associated to each pe in a multicast message.
50  */
51 struct ComlibMulticastIndexCount {
52   int pe;
53   int count;
54 };
55
56 class ComlibMulticastMsg : public CkMcastBaseMsg, 
57                public CMessage_ComlibMulticastMsg {
58     
59   public:
60     int nPes;
61     ComlibMulticastIndexCount *indicesCount;
62     CkArrayIndexMax *indices;
63     char *usrMsg;        
64 };
65
66 class ComlibManager;
67
68 //An Instance of the communication library.
69 class ComlibInstanceHandle : public CkDelegateData {
70  private:    
71     int _instid;
72     CkGroupID _dmid;
73     int _srcPe;
74     int toForward;
75
76  public:
77     ComlibInstanceHandle();
78     ComlibInstanceHandle(const ComlibInstanceHandle &h);
79     ComlibInstanceHandle(int instid, CkGroupID dmid);    
80    
81     ComlibInstanceHandle &operator=(const ComlibInstanceHandle &h);
82
83     void setForwardingOnMigration(){toForward = 1;} 
84     void beginIteration();
85     void endIteration();
86     
87     CkGroupID getComlibManagerID();
88     void setStrategy(CharmStrategy *);
89     CharmStrategy *getStrategy();        
90     int getSourcePe() {return _srcPe;}
91
92     void setSourcePe() {_srcPe = CkMyPe();}
93
94     friend class ComlibManager;
95     void pup(PUP::er &p) {
96
97         if(p.isUnpacking())
98              reset();        
99
100         p | _instid;
101         p | _dmid;
102         p | _srcPe;
103         p | toForward;
104     }
105 };
106
107 class LBMigrateMsg;
108
109 class ComlibManager: public CkDelegateMgr {
110     friend class ComlibInstanceHandle;
111
112     int *bcast_pelist;  //Pelist passed to all broadcast operations
113
114     int section_send_event;
115
116     int remotePe;
117     CmiBool isRemote;
118     CmiBool strategyCreated;
119
120     int npes;
121     int *pelist;
122
123     CkArrayIndexMax dummyArrayIndex;
124
125     //For compatibility and easier use!
126     int strategyID; //Identifier of the strategy
127
128     //Pointer to the converse comm lib strategy table
129     StrategyTable *strategyTable;
130
131     CkQ<CharmStrategy *> ListOfStrategies; //temporary list of strategies
132     
133     CkQ<CharmMessageHolder *> remoteQ;  //list of remote messages
134                                         //after the object has
135                                         //migrated
136
137     //The number of strategies created by the user
138     //int nstrats; //now part of conv comlib
139     
140     int curStratID, prevStratID;      
141     //Number of strategies created by the user.
142
143     //flags
144     int receivedTable, setupComplete, barrierReached, barrier2Reached;
145     CmiBool lbUpdateReceived;
146
147     int bcount , b2count;
148     //int totalMsgCount, totalBytes, nIterations;
149
150     ComlibArrayListener *alistener;
151     int prioEndIterationFlag;
152
153     ComlibGlobalStats clib_gstats; 
154     int    numStatsReceived;
155
156     int curComlibController;   //Processor where strategies are  recreated
157     int clibIteration;         //Number of such learning iterations,
158                                //each of which is triggered by a
159                                //loadbalancing operation
160
161     void init(); //initialization function
162
163     //charm_message for multicast for a section of that group
164     void multicast(CharmMessageHolder *cmsg); //charm message holder here
165     //void multicast(void *charm_msg, int npes, int *pelist);
166
167     //The following funtions can be accessed only from ComlibInstanceHandle
168     void beginIteration();     //Notify begining of a bracket with
169                                //strategy identifier
170
171     void endIteration();       //Notify end, endIteration must be
172                                //called if a beginIteration is
173                                //called. Otherwise end of the entry
174                                //method is assumed to be the end of
175                                //the bracket.
176     
177     void setInstance(int id); 
178
179     //void prioEndIteration(PrioMsg *pmsg);
180     void registerStrategy(int pos, CharmStrategy *s);
181
182  public:
183
184     ComlibLocalStats clib_stats;   //To store statistics of
185                                    //communication operations
186     
187     ComlibManager();  //Recommended constructor
188
189     ComlibManager(CkMigrateMessage *m) { }
190     int useDefCtor(void){ return 1; } //Use default constructor should
191     //be pupped and store all the strategies.
192     
193     void barrier(void);
194     void barrier2(void);
195     void resumeFromBarrier2(void);
196
197     //Receive table of strategies.
198     void receiveTable(StrategyWrapper &sw, 
199                       CkHashtableT <ClibGlobalArrayIndex, int>&); 
200
201     void ArraySend(CkDelegateData *pd,int ep, void *msg, 
202                    const CkArrayIndexMax &idx, CkArrayID a);
203
204     void receiveRemoteSend(CkQ<CharmMessageHolder*> &rq, int id);
205     void sendRemote();
206
207     void GroupSend(CkDelegateData *pd, int ep, void *msg, int onpe, 
208                    CkGroupID gid);
209     
210     virtual void ArrayBroadcast(CkDelegateData *pd,int ep,void *m,CkArrayID a);
211     virtual void GroupBroadcast(CkDelegateData *pd,int ep,void *m,CkGroupID g);
212     virtual void ArraySectionSend(CkDelegateData *pd, int ep ,void *m, 
213                                   CkArrayID a, CkSectionID &s, int opts);
214
215     CharmStrategy *getStrategy(int instid)
216         {return (CharmStrategy *)(* strategyTable)[instid].strategy;}
217
218     StrategyTableEntry *getStrategyTableEntry(int instid)
219         {return &((*strategyTable)[instid]);}
220
221     //To create a new strategy, returns handle to the strategy table;
222     ComlibInstanceHandle createInstance();  
223     void broadcastStrategies();             //Done creating instances
224
225     void AtSync();           //User program called loadbalancer
226     void lbUpdate(LBMigrateMsg *); //loadbalancing updates
227
228     //Learning functions
229     //void learnPattern(int totalMessageCount, int totalBytes);
230     //void switchStrategy(int strat);
231
232     void setRemote(int remotePe);
233
234     void collectStats(ComlibLocalStats &s, int src,CkVec<ClibGlobalArrayIndex>&);
235
236     //Returns the processor on which the comlib sees the array element
237     //belonging to
238     inline int getLastKnown(CkArrayID a, CkArrayIndexMax &idx) {
239         return ComlibGetLastKnown(a, idx);
240     }
241
242     CkDelegateData* ckCopyDelegateData(CkDelegateData *data); 
243     CkDelegateData *DelegatePointerPup(PUP::er &p,CkDelegateData *pd);
244 };
245
246 void ComlibDelegateProxy(CProxy *proxy);
247 void ComlibAssociateProxy(CharmStrategy *strat, CProxy &proxy); 
248 void ComlibBegin(CProxy &proxy);    
249 void ComlibEnd(CProxy &proxy);    
250
251 ComlibInstanceHandle CkCreateComlibInstance();
252 ComlibInstanceHandle CkGetComlibInstance();
253 ComlibInstanceHandle CkGetComlibInstance(int id);
254
255 void ComlibResetSectionProxy(CProxySection_ArrayBase *sproxy);
256
257 inline void ComlibResetProxy(CProxy *aproxy) {
258   ComlibInstanceHandle *handle = 
259     (ComlibInstanceHandle *) aproxy->ckDelegatedPtr();
260   handle->setSourcePe();
261 }
262
263 //Only Called when the strategies are not being created in main::main
264 void ComlibDoneCreating(); 
265
266 void ComlibInitSectionID(CkSectionID &sid);
267
268 void ComlibAtSync(void *msg);
269 void ComlibNotifyMigrationDoneHandler(void *msg);
270 void ComlibLBMigrationUpdate(LBMigrateMsg *);
271
272 #define RECORD_SEND_STATS(sid, bytes, dest) {             \
273         CProxy_ComlibManager cgproxy(CkpvAccess(cmgrID));               \
274         cgproxy.ckLocalBranch()->clib_stats.recordSend(sid, bytes, dest); \
275 }\
276
277 #define RECORD_RECV_STATS(sid, bytes, src) { \
278         CProxy_ComlibManager cgproxy(CkpvAccess(cmgrID)); \
279         cgproxy.ckLocalBranch()->clib_stats.recordRecv(sid, bytes, src); \
280 }\
281
282 #define RECORD_SENDM_STATS(sid, bytes, dest_arr, ndest) {       \
283         CProxy_ComlibManager cgproxy(CkpvAccess(cmgrID)); \
284         cgproxy.ckLocalBranch()->clib_stats.recordSendM(sid, bytes, dest_arr, ndest); \
285 }\
286
287 #define RECORD_RECVM_STATS(sid, bytes, src_arr, nsrc) {        \
288         CProxy_ComlibManager cgproxy(CkpvAccess(cmgrID)); \
289         cgproxy.ckLocalBranch()->clib_stats.recordRecvM(sid, bytes, src_arr, nsrc); \
290 }\
291
292 #endif