Merge cleanup fixes before static array optimizations
[charm.git] / src / conv-com / routerstrategy.h
1 /**
2    @addtogroup ComlibConverseStrategy
3    @{
4    @file
5 */
6
7
8
9
10 #ifndef ROUTER_STRATEGY
11 #define ROUTER_STRATEGY
12
13 #include "convcomlibmanager.h"
14 #include "router.h"
15
16 void routerProcManyCombinedMsg(char *msg);
17 void routerRecvManyCombinedMsg(char *msg);
18 void routerDummyMsg(DummyMsg *msg);
19
20 /**
21    Class that calls Krishnan's routers from the new Comlib. Developed to be
22    called from Converse and from Charm through inheritance by high level
23    strategies.
24
25    Strategy optimizes all-to-all communication. It combines messages and sends
26    them along virtual topologies 2d mesh, 3d mesh and hypercube routers.
27
28    For large messages send them directly.
29
30    Sameer Kumar 05/14/04
31    
32 */
33 class RouterStrategy : public Strategy {
34
35     Router * router;
36     CkQ<MessageHolder *> msgQ;
37     CkQ<char *> recvQ, procQ;
38     CkQ<DummyMsg *> dummyQ;
39
40     comID id;
41     /// A list of all the processors involved in the operation, used when
42     /// sending direcly without routing. This array is shared with the router.
43     int *pelist;
44     /// Size of pelist
45     int npes;
46     /// A sublist of pelist containing only processors which are source
47     int *srcPelist;
48     /// Size of srcPelist
49     int nsrcPes;
50     /// A sublist of pelist containing only processors which are destination
51     int *destPelist;
52     /// size of destPelist
53     int ndestPes;
54     
55     /// A list of size CkNumPes() which associate each processor number with the
56     /// position it occupies in pelist (basically procMap[i]=pelist.indexOf(i))
57     int *procMap;
58     /// A simple array of size npes, where bcast_pemap[i]=i
59     int *bcast_pemap;
60     /// Position occupied by this processor in the list of processors currently
61     /// involved in this operation
62     int myPe;
63     /// Type of Router used by the strategy as subsystem
64     int routerID;
65
66     int doneHandle;    //Array strategy done handle
67     //int myDoneHandle;   //my own done handle, which will inturn call
68                        //array strategy done handle
69  
70     int doneFlag, bufferedDoneInserting;
71
72     /// The processor list used to update the knowledge of the strategy is
73     /// stored here if when it is delivered there is still an operation in
74     /// execution. In this case we have to wait for it to finish, and then
75     /// proceed to update the Router.
76     int *newKnowledge;
77     /// Size of newKnowledge when it is in use
78     int newKnowledgeSize;
79     /// Similar to newKnowledge only for the source list
80     int *newKnowledgeSrc;
81     /// Size of newKnowledgeSrc when it is in use
82     int newKnowledgeSrcSize;
83     /// Similar to newKnowledge only for the destination list
84     int *newKnowledgeDest;
85     /// Size of newKnowledgeDest when it is in use
86     int newKnowledgeDestSize;
87
88     void setReverseMap();
89
90  protected:
91     /// Used only by subclasses to initialize partially.
92     /// bracketedUpdatePeKnowledge is then used to finish the setup and create
93     /// all the final information.
94     RouterStrategy(int stratid);
95
96     /// Type of subsystem specified for the strategy, routerID can become
97     /// USE_DIRECT if no objects are local, but then it can become again what
98     /// required
99     int routerIDsaved;
100
101     char isAllToAll() {return id.isAllToAll;}
102  public:
103     /// Constructor
104     /// @param stratid which topology to use ? (Mesh?, Grid?, Hypercube ?).
105     /// @param handle converse handle that will be called upon finish of an iteration.
106     /// @param nsrc number of source processors in the all to all operation.
107     /// @param srclist list of source processors.
108     /// @param ndest number of destination processors in the all to all operation.
109     /// @param destlist list of destination processors.
110     /// If the last two paramenters are not specified then it is assumes source
111     /// and destination to be equivalent.
112     RouterStrategy(int stratid, int handle, int nsrc, int *srclist, int ndest=0, int *destlist=0);
113     RouterStrategy(CkMigrateMessage *m): Strategy(m) {
114       ComlibPrintf("[%d] RouterStrategy migration constructor\n",CkMyPe());
115     }
116     void setupRouter();
117     
118     ~RouterStrategy();
119
120     Router *getRouter() {return router;}
121     comID &getComID() {return id;}
122
123     //Insert messages
124     virtual void insertMessage(MessageHolder *msg);
125     //Finished inserting
126     virtual void doneInserting();
127
128     /// This function is not used since the Router uses its own handlers
129     virtual void handleMessage(void *m) {
130       CmiAbort("No message should go through RoutingStrategy::handleMessage\n");
131     }
132
133     // In converse simply call CmiSyncSendAndFree
134     virtual void deliver(char *, int); 
135     //{ CmiAbort("No message should go through RoutingStrategy::deliver\n");
136     //}
137
138     void bracketedUpdatePeKnowledge(int *count);
139
140     
141     virtual void notifyDone();
142
143     int * getProcMap() {return procMap;}
144
145     virtual void pup(PUP::er &p);
146     PUPable_decl(RouterStrategy);
147 };
148
149
150
151 #endif
152
153 /*@}*/