- Moved 4 files (ComlibStrategy.*, ComlibArrayListener.*) from ck-core to the
[charm.git] / src / ck-com / ComlibStrategy.h
1 #ifndef COMMLIBSTRATEGY_H
2 #define COMMLIBSTRATEGY_H
3
4 #include "charm++.h"
5 #include "convcomlibstrategy.h"
6
7 //Class managing Charm++ messages in the communication library.
8 //It is aware of envelopes, arrays, etc
9 class CharmMessageHolder : public MessageHolder{
10  public:
11     CkSectionID *sec_id;
12
13     CharmMessageHolder() : MessageHolder() {sec_id = NULL;}
14     CharmMessageHolder(CkMigrateMessage *m) : MessageHolder(m) {}
15     
16     CharmMessageHolder(char * msg, int dest_proc);
17     ~CharmMessageHolder();
18
19     char * getCharmMessage();
20     
21     virtual void pup(PUP::er &p);
22     PUPable_decl(CharmMessageHolder);
23 };
24
25 //Info classes that help bracketed streategies manage objects
26 //Each info class points to a list of source (or destination) objects
27 //ArrayInfo also access the array listener interface
28
29 class ComlibNodeGroupInfo {
30  protected:
31     CkNodeGroupID ngid;
32     int isNodeGroup;
33
34  public:
35     ComlibNodeGroupInfo();
36
37     void setSourceNodeGroup(CkNodeGroupID gid) {
38         ngid = gid;
39         isNodeGroup = 1;
40     }
41
42     int isSourceNodeGroup(){return isNodeGroup;}
43     CkNodeGroupID getSourceNodeGroup();
44
45     void pup(PUP::er &p);
46 };
47
48 class ComlibGroupInfo {
49  protected:
50     CkGroupID gid;
51     int *srcpelist, nsrcpes; //src processors for the elements
52     int isGroup;   
53
54  public:
55     ComlibGroupInfo();
56
57     void setSourceGroup(CkGroupID gid, int *srcpelist=0, int nsrcpes=0);
58     int isSourceGroup(){return isGroup;}
59     void getSourceGroup(CkGroupID &gid);
60     void getSourceGroup(CkGroupID &gid, int *&pelist, int &npes);
61     
62     void pup(PUP::er &p);
63 };
64
65 class ComlibMulticastMsg;
66
67 /* Array strategy helper class.
68    Stores the source and destination arrays.
69    Computes most recent processor maps of source and destinaton arrays.
70    
71    Array section helper functions, make use of sections easier for the
72    communication library.
73 */
74
75 class ComlibArrayInfo {
76  protected:
77     CkArrayID src_aid;
78     CkArrayIndexMax *src_elements; //src array elements
79     int nSrcIndices;              //number of source indices   
80     int isSrcArray;
81
82     CkArrayID dest_aid;
83     CkArrayIndexMax *dest_elements; //dest array elements
84     int nDestIndices;              //number of destintation indices   
85     int isDestArray;
86
87     CkVec<CkArrayIndexMax> localDestIndexVec;
88     
89  public:
90     ComlibArrayInfo();
91
92     void setSourceArray(CkArrayID aid, CkArrayIndexMax *e=0, int nind=0);
93     int isSourceArray(){return isSrcArray;}
94     void getSourceArray(CkArrayID &aid, CkArrayIndexMax *&e, int &nind);
95     
96     void setDestinationArray(CkArrayID aid, CkArrayIndexMax *e=0, int nind=0);
97     int isDestinationArray(){return isDestArray;}
98     void getDestinationArray(CkArrayID &aid, CkArrayIndexMax *&e, int &nind);
99
100     void localBroadcast(envelope *env);
101     static void localMulticast(CkVec<CkArrayIndexMax> *idx_vec,envelope *env);
102     static void deliver(envelope *env);
103
104     void getSourcePeList(int *&pelist, int &npes);
105     void getDestinationPeList(int *&pelist, int &npes);
106     void getCombinedPeList(int *&pelist, int &npes);
107     
108     void pup(PUP::er &p);
109 };
110
111
112 /* All Charm++ communication library strategies should inherit from
113    this strategy. They should specify their object domain by setting
114    Strategy::type. They have three helpers predefined for them for
115    node groups, groups and arrays */
116
117 class CharmStrategy : public Strategy {
118     int forwardOnMigration;
119
120  public:
121     ComlibGroupInfo ginfo;
122     ComlibNodeGroupInfo nginfo;
123
124     //The communication library array listener watches and monitors
125     //the array elements belonging to ainfo.src_aid
126     ComlibArrayInfo ainfo;
127     
128     CharmStrategy() : Strategy() {
129         setType(GROUP_STRATEGY); 
130         forwardOnMigration = 0;
131     }
132
133     CharmStrategy(CkMigrateMessage *m) : Strategy(m){}
134
135     //Called for each message
136     //Function inserts a Charm++ message
137     virtual void insertMessage(CharmMessageHolder *msg) {
138       CkAbort("Bummer Should Not come here:CharmStrategy is abstract\n");
139     }
140
141     //Removed the virtual!
142     //Charm strategies should not use Message Holder
143     void insertMessage(MessageHolder *msg);
144     
145     //Called after all chares and groups have finished depositing their 
146     //messages on that processor.
147     // DUPLICATED virtual void doneInserting() {}
148
149     //Added a new call that is called after the strategy had be
150     //created on every processor.
151     //DOES NOT exist in Converse Strategies
152     virtual void beginProcessing(int nelements){}
153
154     virtual void pup(PUP::er &p);
155     PUPable_decl(CharmStrategy);
156
157     void setForwardOnMigration(int f) {
158         forwardOnMigration = f;
159     }
160     
161     int getForwardOnMigration() {
162         return forwardOnMigration;
163     }
164 };
165
166 #endif