The new version of comlib! This version passed "make test" in charm/tests on order...
[charm.git] / src / ck-com / RectMulticastStrategy.h
1 #ifndef RECT_MULTICAST_STRATEGY
2 #define RECT_MULTICAST_STRATEGY
3
4
5 /**
6    @addtogroup ComlibCharmStrategy
7    @{
8    @file
9    @brief RectMulticastStrategy for BG/L native layer
10 */
11
12
13 // only works on BG/L Native Layer
14
15 #include "ComlibManager.h"
16 #include "ComlibSectionInfo.h"
17
18 typedef CkHashtableTslow < unsigned int, void *> comRectHashType;
19 //typedef CkHashtableT < unsigned int, int > comRectHashType;
20
21 CkpvExtern(comRectHashType *, com_rect_ptr);
22
23
24 // need place to record 'src in rectangle' state
25 class ComlibRectSectionHashObject : public ComlibSectionHashObject
26 {
27  public:
28   bool sourceInRectangle;
29   int cornerRoot;
30   CkArrayID aid;
31 };
32
33 void *DMHandler(void *msg);
34 /**
35  * Main class for multicast strategies. It defaults to sending a direct message
36  * to all the processors involved in the multicast.
37
38  * The definition of the section, as well as the location of all the elements in
39  * the processors is determined by the sending processor. The other will obey to
40  * it, even some elements have already migrated elsewhere.
41  */
42 #ifdef CMK_RECT_API
43 #include "bgml.h"
44 class RectMulticastStrategy: public Strategy, public CharmStrategy {
45  protected:
46     int handlerId;    
47     ComlibSectionInfo sinfo;
48
49     int isPersistent; 
50     
51     ///Array section support.
52     CkHashtableT<ComlibSectionHashKey, ComlibRectSectionHashObject *> sec_ht; 
53
54
55     inline unsigned int computeKey(int sectionID, int srcPe, CkArrayID arrId) {
56       //      fprintf(stderr,"key %d %d %d = %d\n",(((CkGroupID) arrId).idx), (sectionID), srcPe, (((CkGroupID) arrId).idx << 24) | (sectionID<<16)| srcPe);
57       return ((unsigned int) (((CkGroupID) arrId).idx << 24) | (sectionID<<16)| srcPe);}
58     
59     inline unsigned int computeKey(int sectionID, int srcPe, int id) { 
60       //      fprintf(stderr,"key %d %d %d = %d", id ,sectionID,  srcPe, (id  << 24) | (sectionID<<16)| srcPe);
61       return ((unsigned int) (id  << 24) | (sectionID<<16)| srcPe);}
62     
63     ///Add this section to the hash table locally.
64     void insertSectionID(CkSectionID *sid);
65
66     ///Called when a new section multicast is called by the user locally.
67     ///The strategy should then create a topology for it and return a hash
68     ///object to store that topology.
69     virtual ComlibRectSectionHashObject *createObjectOnSrcPe(int nindices, CkArrayIndexMax *idx_list, unsigned int sectionid);
70
71     /**   
72      * Similar to createHashObjectOnSrcPe, but that this call is made on the
73      * destination or intermediate processor. I receives all the information in
74      * the parameters, and it does not use ComlibLastKnown, since in some cases
75      * it can be incoherent.
76
77      * @param nindices number of local elements to multicast
78      * @param idxlist list of local elements
79      * @param npes number of processors involved in the multicast
80      * @param counts list of all the processors involved int the multicast
81      * @param srcpe processor which started the multicast
82      * @return a hash object describing the section
83      */
84     virtual ComlibRectSectionHashObject *createObjectOnIntermediatePe(int nindices, CkArrayIndexMax *idxlist, int npes, ComlibMulticastIndexCount *counts, int srcpe, int sectionID);
85         
86     ///Needed for getNewMulticastMessage, to specify if the list of processors need to be ordered
87     virtual int needSorting() { return 0; }
88
89     ///Called to multicast the message to local array elements.
90     void localMulticast(envelope *env, ComlibRectSectionHashObject *obj);
91     
92     ///Called to send to message out to the remote destinations.
93     ///This method can be overridden to call converse level strategies.
94     virtual void remoteMulticast(envelope *env, ComlibRectSectionHashObject *obj);
95
96     ///Called to forward to someone who can do the heavy sending work
97     virtual void forwardMulticast(envelope *env, ComlibRectSectionHashObject *obj);
98
99
100     ///Process a new message by extracting the array elements from it and
101     ///creating a new hash object by calling createObjectOnIntermediatePe().
102     void handleNewMulticastMessage(envelope *env);
103
104     void sendRectDest(ComlibRectSectionHashObject *obj, int srcpe, envelope *env);
105     BGTsRC_Geometry_t *getRectGeometry(ComlibRectSectionHashObject *obj, int srcpe);
106     int assignCornerRoot(BGTsRC_Geometry_t *geom, int srcpe);
107
108  public:
109
110
111
112     RectMulticastStrategy(CkMigrateMessage *m): Strategy(m), CharmStrategy(m){}
113                 
114     ///Array constructor
115     RectMulticastStrategy(CkArrayID aid, int isPersistent = 0);
116         
117         
118     //Destuctor
119     ~RectMulticastStrategy();
120         
121     virtual void insertMessage(CharmMessageHolder *msg);
122     virtual void doneInserting();
123
124     ///Called by the converse handler function
125     virtual void handleMessage(void *msg);    
126     virtual void handleMessageForward(void *msg);    
127
128     virtual void pup(PUP::er &p);    
129     virtual void beginProcessing(int nelements);
130     
131     PUPable_decl(RectMulticastStrategy);
132 };
133 #else
134 class RectMulticastStrategy : public Strategy, public CharmStrategy {   
135   RectMulticastStrategy(CkMigrateMessage *m): Strategy(m), CharmStrategy(m){}
136   //    RectMulticastStrategy(CkArrayID aid, int isPersistent = 0){}
137   ~RectMulticastStrategy(){}
138   void insertMessage(MessageHolder*) {}
139   void handleMessage(void*) {}
140   void pup(PUP::er &p) {}
141   PUPable_decl(RectMulticastStrategy);   
142 };
143 #endif
144
145
146 /*@}*/
147
148 #endif