The new version of comlib! This version passed "make test" in charm/tests on order...
[charm.git] / src / conv-com / router.h
1 /**
2    @addtogroup ConvComlibRouter
3    @{
4    @file 
5    @brief Base class for routers. 
6 */
7
8 #ifndef ROUTER_H
9 #define ROUTER_H
10
11
12 #include "cklists.h"
13 #include "convcomlibmanager.h"
14 #include <math.h>
15
16 /*******************************
17  * Structures copied from old convcomlib.h - Filippo
18  *******************************/
19 #define MAXNUMMSGS 1000
20
21 /** Used between RouterStrategy and Router(s) to pass some information: a
22     RouterStrategy passes its comID to the Router it uses, so the second have
23     some knowledge of the containing strategy. */
24 typedef struct {
25     int refno;
26     int instanceID;  
27     char isAllToAll;
28 } comID;
29 inline void operator|(PUP::er& p, comID& id) {
30   p | id.refno;
31   p | id.instanceID;
32   p | id.isAllToAll;
33 }
34
35 typedef struct {
36   int msgsize;
37   void *msg;
38 } msgstruct ;
39
40 typedef struct { 
41     char core[CmiReservedHeaderSize];
42     comID id;
43     int magic;
44     int refno;
45 } DummyMsg ;
46
47 //The handler to invoke the RecvManyMsg method of router
48 CkpvExtern(int, RouterRecvHandle);
49 //The handler to invoke the ProcManyMsg method of router
50 CkpvExtern(int, RouterProcHandle);
51 //The handler to invoke the DoneEP method of router
52 CkpvExtern(int, RouterDummyHandle);
53
54 //Dummy msg handle.
55 //Just deletes and ignores the message
56 CkpvExtern(int, RecvdummyHandle);
57
58 inline double cubeRoot(double d) {
59   return pow(d,1.0/3.0);
60 }
61
62
63
64
65 /** Base class for routers.
66     Imported from Krishnan's Each To Many Communication Framework.
67     Modified to suit the new communication library.
68     Sameer Kumar 05/14/04
69 */
70
71 class Router 
72 {
73   //int doneHandle;
74  protected:
75   Strategy *container;
76     
77  public:
78     Router(Strategy *cont) : container(cont) {};
79     virtual ~Router() {};
80     
81     /// Insert messages for the all to all operation,
82     /// All processors will be multicast the same message here.
83     virtual void EachToAllMulticast(comID id, int size, void *msg, int more)
84       {CmiPrintf("Not impl\n");}
85     
86     /// Insert messages for the all to all operation, The destination
87     /// processors to which a message is multicast to be can be
88     /// specified.
89     /// @param id communication operation identifier
90     /// @param size size of the message
91     /// @param msg message to be sent
92     /// @param numPes number of processors the message has to be sent to
93     /// @param pelist list of relative proc ids the message has to be multicast to
94     virtual void EachToManyMulticast(comID id, int size, void *msg, 
95                                      int numPes, int *pelist, int more)
96       {CmiPrintf("Not impl\n");}
97
98     /// Same as EachToManyMulticast, only it receives all the messages into a list
99     virtual void EachToManyMulticastQ(comID id, CkQ<MessageHolder *> &msgq){
100         MessageHolder *mhdl;
101         int len = msgq.length();
102         for(int count = 0; count < len - 1; count++) {
103             mhdl = msgq.deq();
104             EachToManyMulticast(id, mhdl->size, mhdl->getMessage(), 
105                                 mhdl->npes, mhdl->pelist, 1);
106             delete mhdl;
107         }
108         mhdl = msgq.deq();
109         EachToManyMulticast(id, mhdl->size, mhdl->getMessage(), 
110                             mhdl->npes, mhdl->pelist, 0);
111         delete mhdl;
112     }
113
114     //The first iteration of message combining should call this
115     //entry function
116     virtual void RecvManyMsg(comID, char *) {CmiPrintf("Not Impl\n");}
117     
118     //The send and the rest of the iterations should call this
119     //entry function
120     virtual void ProcManyMsg(comID, char *) {CmiPrintf("Not Impl\n");}
121     
122     //Received a dummy
123     virtual void DummyEP(comID, int )   {CmiPrintf("Base Dummy\n");}
124     
125     /// Set the map between processors and virtual processor id's,
126     /// Useful when only a subset of processors are involved in the
127     /// communication operation.
128     virtual void SetMap(int *) {}
129
130     //Utility function
131     void SendDummyMsg(comID id, int pe, int magic) {
132         
133         ComlibPrintf("[%d] Send Dummy to %d\n", CkMyPe(), pe);
134
135         DummyMsg *m=(DummyMsg *)CmiAlloc(sizeof(DummyMsg));
136         CmiSetHandler(m, CkpvAccess(RouterDummyHandle));
137         m->id=id;
138         m->magic=magic;
139         CmiSyncSendAndFree(pe, sizeof(DummyMsg),(char*) m);
140     }
141
142     /// set the handler that will be called when an iteration finishes
143     //void setDoneHandle(int handle) {
144     //    doneHandle = handle;
145     //}
146
147     /// called by the subclasses when the iteration has completed
148     void Done(comID id) {
149       Strategy *myStrategy = ConvComlibGetStrategy(id.instanceID);
150       myStrategy->notifyDone();
151
152         //ComlibPrintf("Router Iteration Finished %d", CkMyPe());
153       /*
154         if(doneHandle == 0)
155             return;
156
157         DummyMsg *m=(DummyMsg *)CmiAlloc(sizeof(DummyMsg));
158         m->id=id;
159         CmiSetHandler(m, doneHandle);
160         CmiSyncSendAndFree(CkMyPe(), sizeof(DummyMsg), (char*)m);
161       */
162     }
163 };
164
165 #endif
166
167
168 /*@}*/