adding a hook to get a strategy pointer in the user program from the instancehandle
[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 #define IS_MULTICAST -1
28
29 #define ALPHA 5E-6
30 #define BETA 3.33E-9
31
32 PUPbytes(comID);
33
34 #include "comlib.decl.h"
35
36 //Dummy message to be sent incase there are no messages to send. 
37 //Used by only the EachToMany strategy!
38 class ComlibDummyMsg: public CMessage_ComlibDummyMsg {
39     int dummy;
40 };
41
42 /*
43 //Priority message to call end iteration
44 class PrioMsg: public CMessage_PrioMsg {
45  public:
46     int instID;
47 };
48 */
49
50 class ComlibMulticastMsg : public CkMcastBaseMsg, 
51                public CMessage_ComlibMulticastMsg {
52     
53   public:
54     int nIndices;
55     char *usrMsg;        
56     CkArrayIndexMax *indices;
57 };
58
59 class ComlibManager;
60
61 extern CkGroupID cmgrID;
62
63 //An Instance of the communication library.
64 class ComlibInstanceHandle {
65  private:    
66     
67     int _instid;
68     CkGroupID _dmid;
69     int _srcPe;
70     int toForward;
71     
72  public:
73     ComlibInstanceHandle();
74     ComlibInstanceHandle(const ComlibInstanceHandle &h);
75     ComlibInstanceHandle(int instid, CkGroupID dmid);    
76     
77     void init();
78     void beginIteration();
79     void endIteration();
80     
81     CkGroupID getComlibManagerID();
82     void setStrategy(CharmStrategy *);
83     CharmStrategy *getStrategy();        
84     int getSourcePe() {return _srcPe;}
85
86     friend class ComlibManager;
87     void pup(PUP::er &p) {
88         p | _instid;
89         p | _dmid;
90         p | _srcPe;
91         p | toForward;
92
93         //Fresh instance handle, so set My processor
94         if(p.isUnpacking())
95             if(_srcPe == -1)
96                 _srcPe = CkMyPe();
97     }
98 };
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
110     int npes;
111     int *pelist;
112
113     CkArrayIndexMax dummyArrayIndex;
114
115     //For compatibility and easier use!
116     int strategyID; //Identifier of the strategy
117
118     //Pointer to the converse comm lib strategy table
119     StrategyTable *strategyTable;
120
121     CkVec<CharmStrategy *> ListOfStrategies; //temporary list of strategies
122     
123     CkQ<CharmMessageHolder *> remoteQ;  //list of remote messages
124                                         //after the object has
125                                         //migrated
126
127     //The number of strategies created by the user
128     int nstrats; 
129     
130     int curStratID, prevStratID;      
131     //Number of strategies created by the user.
132
133     //flags
134     int receivedTable, flushTable, barrierReached, barrier2Reached;
135     int totalMsgCount, totalBytes, nIterations;
136
137     ComlibArrayListener *alistener;
138     int prioEndIterationFlag;
139
140     void init(); //initialization function
141
142     //charm_message for multicast for a section of that group
143     void multicast(CharmMessageHolder *cmsg); //charm message holder here
144     //void multicast(void *charm_msg, int npes, int *pelist);
145
146     //The following funtions can be accessed only from ComlibInstanceHandle
147     void beginIteration();     //Notify begining of a bracket with
148                                //strategy identifier
149
150     void endIteration();       //Notify end, endIteration must be
151                                //called if a beginIteration is
152                                //called. Otherwise end of the entry
153                                //method is assumed to be the end of
154                                //the bracket.
155     
156     void setInstance(int id); 
157     //void prioEndIteration(PrioMsg *pmsg);
158     void registerStrategy(int pos, CharmStrategy *s);
159
160  public:
161     ComlibManager();  //Recommended constructor
162
163     ComlibManager(CkMigrateMessage *m){ }
164     int useDefCtor(void){ return 1; } //Use default constructor should
165     //be pupped and store all the strategies.
166     
167     void barrier(void);
168     void barrier2(void);
169     void resumeFromBarrier2(void);
170     void receiveTable(StrategyWrapper sw); //Receive table of strategies.
171
172     void ArraySend(CkDelegateData *pd,int ep, void *msg, const CkArrayIndexMax &idx, 
173                    CkArrayID a);
174
175     void receiveRemoteSend(CkQ<CharmMessageHolder*> &rq, int id);
176     void sendRemote();
177
178     void GroupSend(CkDelegateData *pd,int ep, void *msg, int onpe, CkGroupID gid);
179     
180     virtual void ArrayBroadcast(CkDelegateData *pd,int ep,void *m,CkArrayID a);
181     virtual void GroupBroadcast(CkDelegateData *pd,int ep,void *m,CkGroupID g);
182     virtual void ArraySectionSend(CkDelegateData *pd,int ep,void *m,CkArrayID a,CkSectionID &s);
183
184     CharmStrategy *getStrategy(int instid)
185         {return (CharmStrategy *)(* strategyTable)[instid].strategy;}
186
187     StrategyTableEntry *getStrategyTableEntry(int instid)
188         {return &((*strategyTable)[instid]);}
189
190     //To create a new strategy, returns handle to the strategy table;
191     ComlibInstanceHandle createInstance();  
192     void doneCreating();             //Done creating instances
193
194     //Learning functions
195     void learnPattern(int totalMessageCount, int totalBytes);
196     void switchStrategy(int strat);
197
198     void setRemote(int remotePe);
199 };
200
201 void ComlibDelegateProxy(CProxy *proxy);
202
203 ComlibInstanceHandle CkCreateComlibInstance();
204 ComlibInstanceHandle CkGetComlibInstance();
205 ComlibInstanceHandle CkGetComlibInstance(int id);
206
207 //Only Called when the strategies are not being created in main::main
208 void ComlibDoneCreating(); 
209
210 void ComlibInitSectionID(CkSectionID &sid);
211 void ComlibDeleteSection();
212
213 #endif