adds RectMulticastStrategy. Depends on BGML native layer on BG/L.
[charm.git] / src / ck-com / ComlibSectionInfo.h
1 #ifndef COMLIB_SECTION_INFO
2 #define COMLIB_SECTION_INFO
3
4 /***********
5   Helper classes that help strategies manage array sections 
6 ***********/
7
8 /* Hash key that lets a strategy access a section id data structure
9    given the source processor and the MaxSectionId on that processor
10 */
11 class ComlibSectionHashKey{
12  public:
13     int srcPe;
14     int id;
15     ComlibSectionHashKey(int _pe, int _id):srcPe(_pe), id(_id){};
16
17     //These routines allow ComlibSectionHashKey to be used in
18     //  a CkHashtableT
19     CkHashCode hash(void) const;
20     static CkHashCode staticHash(const void *a,size_t);
21     int compare(const ComlibSectionHashKey &ind) const;
22     static int staticCompare(const void *a,const void *b,size_t);
23 };
24
25 /*********** CkHashTable functions ******************/
26 inline CkHashCode ComlibSectionHashKey::hash(void) const
27 {
28     register int _id = id;
29     register int _pe = srcPe;
30     
31     register CkHashCode ret = (_id << 16) + _pe;
32     return ret;
33 }
34
35 inline int ComlibSectionHashKey::compare(const ComlibSectionHashKey &k2) const
36 {
37     if(id == k2.id && srcPe == k2.srcPe)
38         return 1;
39     
40     return 0;
41 }
42
43 /*For calls to qsort*/
44 inline int intCompare(const void *a, const void *b){
45     int a1 = *(int *) a;
46     int b1 = *(int *) b;
47
48     if(a1 < b1)
49         return -1;
50     
51     if(a1 == b1)
52         return 0;
53
54     if(a1 > b1)
55         return 1;
56
57     return 0;
58 }    
59
60 //ComlibSectionHashKey CODE
61 inline int ComlibSectionHashKey::staticCompare(const void *k1, const void *k2, 
62                                                 size_t ){
63     return ((const ComlibSectionHashKey *)k1)->
64                 compare(*(const ComlibSectionHashKey *)k2);
65 }
66
67 inline CkHashCode ComlibSectionHashKey::staticHash(const void *v,size_t){
68     return ((const ComlibSectionHashKey *)v)->hash();
69 }
70
71 /*************** End CkHashtable Functions *****************/
72
73
74
75 class ComlibSectionHashObject {
76  public:
77     //My local indices
78     CkVec<CkArrayIndexMax> indices;
79     
80     //Other processors to send this message to
81     int npes;
82     int *pelist;
83
84     void *msg;
85     
86     ComlibSectionHashObject(): indices(0) {
87         npes = 0;
88         pelist = NULL;
89         msg = NULL;
90     }
91
92     ~ComlibSectionHashObject() {
93         delete [] pelist;
94         //delete msg;
95     }
96 };
97
98
99 /*** Class that helps a communication library strategy manage array
100      sections
101 ***************/
102
103 class ComlibSectionInfo {
104     /* Array ID of the array section */
105     CkArrayID destArrayID;
106     
107     //Unique section id for this section
108     //Will be used to access a hashtable on remote processors
109     int MaxSectionID;
110
111     //Instance ID of the strategy
112     int instanceID;
113
114     CkVec<CkArrayIndexMax> localDestIndexVec;
115
116  public:
117
118     ComlibSectionInfo() { 
119         destArrayID.setZero(); MaxSectionID = 1; instanceID = 0;    
120     }
121
122     ComlibSectionInfo(CkArrayID dest, int instance){
123         destArrayID = dest;
124         instanceID = instance;
125
126         MaxSectionID = 1;
127     }
128     
129     inline void initSectionID(CkSectionID *sid) {
130         sid->_cookie.sInfo.cInfo.id = MaxSectionID ++;            
131     }
132
133     inline int getInstID(){ return(instanceID);}
134     
135     void processOldSectionMessage(CharmMessageHolder *cmsg);
136
137     /**
138      * Starting from a message to be sent, it generates a new message containing
139      * the information about the multicast, together with the message itself.
140      * The info about the multicast is contained in the field sec_id of cmsg.
141      * The processors will be order by MyPe() if requested.
142      */
143     ComlibMulticastMsg *getNewMulticastMessage(CharmMessageHolder *cmsg, int needSort);
144
145     /**
146      * Given a ComlibMulticastMsg arrived through the network as input (cb_env),
147      * separate it into its basic components.
148
149      * destIndeces is the pointer to the first element in this processor (as by
150      * the knowledge of the sender); nLocalElems is the count of how many
151      * elements are local. env is a new allocated memory containing the user
152      * message.
153      */
154     void unpack(envelope *cb_env, int &nLocalElems, CkArrayIndexMax *&destIndices, 
155                 envelope *&env);
156
157     void localMulticast(envelope *env);
158
159     /**
160      * Returns the number of remote procs involved in the array index list, the
161      * number of elements each proc has, and the mapping between indices and
162      * procs.
163      
164      * @param nindices size of the array idxlist (input)
165      * @param idxlist array of indeces of the section (input)
166      * @param npes number of processors involved (output)
167      * @param nidx number of indices that are remote (output)
168      * @param counts array of associations pe-count: number of elements in proc pe (output, new'ed(CkNumPes()))
169      * @param belongs array of integers expressing association of elements with pes: belongs[i] = index in counts of the processor having index i (output, new'ed(nidx))
170     */
171     void getPeCount(int nindices, CkArrayIndexMax *idxlist, 
172                     int &npes, int &nidx,
173                     ComlibMulticastIndexCount *&counts, int *&belongs);
174
175     void getPeList(envelope *cb_env, int npes, int *&pelist);
176
177     void getRemotePelist(int nindices, CkArrayIndexMax *idxlist, 
178                          int &npes, int *&pelist);
179
180     void getPeList(int nindices, CkArrayIndexMax *idxlist, 
181                    int &npes, int *&pelist);
182
183     void getLocalIndices(int nindices, CkArrayIndexMax *idxlist, 
184                          CkVec<CkArrayIndexMax> &idx_vec);   
185         
186     static inline int getSectionID(CkSectionID id) {
187         return id._cookie.sInfo.cInfo.id;
188     }
189
190     inline CkArrayID getDestArrayID() {
191         return destArrayID;
192     }
193
194     void pup(PUP::er &p) {
195         p | destArrayID;
196         p | MaxSectionID;
197         p | instanceID;
198         p | localDestIndexVec;
199     }
200 };
201
202 #endif