Merge branch 'ramv/cleanup-arridx-hierarchy' into charm
[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     ///Array section support.
50     CkHashtableT<ComlibSectionHashKey, ComlibRectSectionHashObject *> sec_ht; 
51
52
53     inline unsigned int computeKey(int sectionID, int srcPe, CkArrayID arrId) {
54       //      fprintf(stderr,"key %d %d %d = %d\n",(((CkGroupID) arrId).idx), (sectionID), srcPe, (((CkGroupID) arrId).idx << 24) | (sectionID<<16)| srcPe);
55       return ((unsigned int) (((CkGroupID) arrId).idx << 24) | (sectionID<<16)| srcPe);}
56     
57     inline unsigned int computeKey(int sectionID, int srcPe, int id) { 
58       //      fprintf(stderr,"key %d %d %d = %d", id ,sectionID,  srcPe, (id  << 24) | (sectionID<<16)| srcPe);
59       return ((unsigned int) (id  << 24) | (sectionID<<16)| srcPe);}
60     
61     ///Add this section to the hash table locally.
62     void insertSectionID(CkSectionID *sid);
63
64     ///Called when a new section multicast is called by the user locally.
65     ///The strategy should then create a topology for it and return a hash
66     ///object to store that topology.
67     virtual ComlibRectSectionHashObject *createObjectOnSrcPe(int nindices, CkArrayIndex *idx_list, unsigned int sectionid);
68
69     /**   
70      * Similar to createHashObjectOnSrcPe, but that this call is made on the
71      * destination or intermediate processor. I receives all the information in
72      * the parameters, and it does not use ComlibLastKnown, since in some cases
73      * it can be incoherent.
74
75      * @param nindices number of local elements to multicast
76      * @param idxlist list of local elements
77      * @param npes number of processors involved in the multicast
78      * @param counts list of all the processors involved int the multicast
79      * @param srcpe processor which started the multicast
80      * @return a hash object describing the section
81      */
82     virtual ComlibRectSectionHashObject *createObjectOnIntermediatePe(int nindices, CkArrayIndex *idxlist, int npes, ComlibMulticastIndexCount *counts, int srcpe, int sectionID);
83         
84     ///Needed for getNewMulticastMessage, to specify if the list of processors need to be ordered
85     virtual int needSorting() { return 0; }
86
87     ///Called to multicast the message to local array elements.
88     void localMulticast(envelope *env, ComlibRectSectionHashObject *obj);
89     
90     ///Called to send to message out to the remote destinations.
91     ///This method can be overridden to call converse level strategies.
92     virtual void remoteMulticast(envelope *env, ComlibRectSectionHashObject *obj);
93
94     ///Called to forward to someone who can do the heavy sending work
95     virtual void forwardMulticast(envelope *env, ComlibRectSectionHashObject *obj);
96
97
98     ///Process a new message by extracting the array elements from it and
99     ///creating a new hash object by calling createObjectOnIntermediatePe().
100     void handleNewMulticastMessage(envelope *env);
101
102     void sendRectDest(ComlibRectSectionHashObject *obj, int srcpe, envelope *env);
103     BGTsRC_Geometry_t *getRectGeometry(ComlibRectSectionHashObject *obj, int srcpe);
104     int assignCornerRoot(BGTsRC_Geometry_t *geom, int srcpe);
105
106  public:
107
108
109
110     RectMulticastStrategy(CkMigrateMessage *m): Strategy(m), CharmStrategy(m){}
111                 
112     ///Array constructor
113     RectMulticastStrategy(CkArrayID aid);
114         
115         
116     //Destuctor
117     ~RectMulticastStrategy();
118         
119     virtual void insertMessage(CharmMessageHolder *msg);
120     virtual void doneInserting();
121
122     ///Called by the converse handler function
123     virtual void handleMessage(void *msg);    
124     virtual void handleMessageForward(void *msg);    
125
126     virtual void pup(PUP::er &p);    
127     virtual void beginProcessing(int nelements);
128     
129     PUPable_decl(RectMulticastStrategy);
130 };
131 #else
132 class RectMulticastStrategy : public Strategy, public CharmStrategy {   
133   RectMulticastStrategy(CkMigrateMessage *m): Strategy(m), CharmStrategy(m){}
134   //    RectMulticastStrategy(CkArrayID aid){}
135   ~RectMulticastStrategy(){}
136   void insertMessage(MessageHolder*) {}
137   void handleMessage(void*) {}
138   void pup(PUP::er &p) {}
139   PUPable_decl(RectMulticastStrategy);   
140 };
141 #endif
142
143
144 /*@}*/
145
146 #endif