*** empty log message ***
[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
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 section_send_event;
104
105     int remotePe;
106     CmiBool isRemote;
107
108     int npes;
109     int *pelist;
110
111     CkArrayIndexMax dummyArrayIndex;
112
113     //For compatibility and easier use!
114     int strategyID; //Identifier of the strategy
115
116     //Pointer to the converse comm lib strategy table
117     StrategyTable *strategyTable;
118
119     CkVec<CharmStrategy *> ListOfStrategies; //temporary list of strategies
120     
121     CkQ<CharmMessageHolder *> remoteQ;  //list of remote messages
122                                         //after the object has
123                                         //migrated
124
125     //The number of strategies created by the user
126     int nstrats; 
127     
128     int curStratID, prevStratID;      
129     //Number of strategies created by the user.
130
131     //flags
132     int receivedTable, flushTable, barrierReached, barrier2Reached;
133     int totalMsgCount, totalBytes, nIterations;
134
135     ComlibArrayListener *alistener;
136     int prioEndIterationFlag;
137
138     void init(); //initialization function
139
140     //charm_message for multicast for a section of that group
141     void multicast(CharmMessageHolder *cmsg); //charm message holder here
142     //void multicast(void *charm_msg, int npes, int *pelist);
143
144     //The following funtions can be accessed only from ComlibInstanceHandle
145     void beginIteration();     //Notify begining of a bracket with
146                                //strategy identifier
147
148     void endIteration();       //Notify end, endIteration must be
149                                //called if a beginIteration is
150                                //called. Otherwise end of the entry
151                                //method is assumed to be the end of
152                                //the bracket.
153     
154     void setInstance(int id); 
155     //void prioEndIteration(PrioMsg *pmsg);
156     void registerStrategy(int pos, CharmStrategy *s);
157
158  public:
159     ComlibManager();  //Recommended constructor
160
161     ComlibManager(CkMigrateMessage *m){ }
162     int useDefCtor(void){ return 1; } //Use default constructor should
163     //be pupped and store all the strategies.
164     
165     void barrier(void);
166     void barrier2(void);
167     void resumeFromBarrier2(void);
168     void receiveTable(StrategyWrapper sw); //Receive table of strategies.
169
170     void ArraySend(CkDelegateData *pd,int ep, void *msg, const CkArrayIndexMax &idx, 
171                    CkArrayID a);
172
173     void receiveRemoteSend(CkQ<CharmMessageHolder*> &rq, int id);
174     void sendRemote();
175
176     void GroupSend(CkDelegateData *pd,int ep, void *msg, int onpe, CkGroupID gid);
177     
178     virtual void ArrayBroadcast(CkDelegateData *pd,int ep,void *m,CkArrayID a);
179     virtual void GroupBroadcast(CkDelegateData *pd,int ep,void *m,CkGroupID g);
180     virtual void ArraySectionSend(CkDelegateData *pd,int ep,void *m,CkArrayID a,CkSectionID &s);
181
182     CharmStrategy *getStrategy(int instid)
183         {return (CharmStrategy *)(* strategyTable)[instid].strategy;}
184
185     StrategyTableEntry *getStrategyTableEntry(int instid)
186         {return &((*strategyTable)[instid]);}
187
188     //To create a new strategy, returns handle to the strategy table;
189     ComlibInstanceHandle createInstance();  
190     void doneCreating();             //Done creating instances
191
192     //Learning functions
193     void learnPattern(int totalMessageCount, int totalBytes);
194     void switchStrategy(int strat);
195
196     void setRemote(int remotePe);
197 };
198
199 void ComlibDelegateProxy(CProxy *proxy);
200
201 ComlibInstanceHandle CkCreateComlibInstance();
202 ComlibInstanceHandle CkGetComlibInstance();
203 ComlibInstanceHandle CkGetComlibInstance(int id);
204
205 //Only Called when the strategies are not being created in main::main
206 void ComlibDoneCreating(); 
207
208 void ComlibInitSectionID(CkSectionID &sid);
209 void ComlibDeleteSection();
210
211 #endif