modified the registration of the converse handlers for propagate and propagate_frag.
[charm.git] / src / conv-com / convcomlibstrategy.h
1 #ifndef CONVCOMMLIBSTRATEGY_H
2 #define CONVCOMMLIBSTRATEGY_H
3
4 #include "converse.h"
5 #include "pup.h"
6 #include "cklists.h"
7
8 //An abstract data structure that holds a converse message and which
9 //can be buffered by the communication library Message holder is a
10 //wrapper around a message. Has other useful data like destination
11 //processor list for a multicast etc.
12
13 class MessageHolder : public PUP::able {
14  public:
15     int dest_proc;
16     char *data;
17     int size;
18     MessageHolder *next; // also used for the refield at the receiver
19     int isDummy;
20     
21     //For multicast, the user can pass the pelist and list of Pes he
22     //wants to send the data to.
23     int npes;
24     int *pelist;
25     
26     MessageHolder() 
27         {dest_proc = size = isDummy = 0; data = NULL;}    
28
29     MessageHolder(CkMigrateMessage *m) {}
30
31     inline MessageHolder(char * msg, int proc, int sz) {
32         data = msg;
33         dest_proc = proc;
34         size = sz;
35         
36         isDummy = 0;
37         
38         npes = 0;
39         pelist = 0;
40
41     }
42
43     inline ~MessageHolder() {
44         /*
45           if(pelist != NULL && npes > 0)
46           delete[] pelist;
47         */
48     }
49
50     inline char * getMessage() {
51         return data;
52     }
53
54     inline int getSize() {
55       return size;
56     }
57
58     inline void * operator new(size_t size) {
59         return CmiAlloc(size);
60     }
61
62     inline void operator delete (void *buf) {
63         CmiFree(buf);
64     }
65
66     virtual void pup(PUP::er &p);
67     PUPable_decl(MessageHolder);
68 };
69
70 #define CONVERSE_STRATEGY 0     //The strategy works for converse programs
71 #define NODEGROUP_STRATEGY 1    //Node group level optimizations 
72 #define GROUP_STRATEGY 2        //Charm Processor level optimizations
73 #define ARRAY_STRATEGY 3        //Array level optimizations
74
75 //Class that defines the entry methods that a Converse level strategy
76 //must define. To write a new strategy inherit from this class and
77 //define the virtual methods.  Every strategy can also define its own
78 //constructor and have any number of arguments. Also call the parent
79 //class methods in the virtual methods.
80
81 class Strategy : public PUP::able{
82  protected:
83     int type;
84     int isStrategyBracketed;
85     int myInstanceID;
86     int destinationHandler;
87
88     //Charm strategies for modularity may have converse strategies in
89     //them.  For the code to work in both Charm and converse, this
90     //variable can be used.    
91     Strategy *converseStrategy;
92     Strategy *higherLevel;
93
94  public:
95     Strategy();
96     Strategy(CkMigrateMessage *m) : PUP::able(m) {
97         converseStrategy = this;
98         higherLevel = this;
99     }
100
101     inline void setBracketed(){isStrategyBracketed = 1;}
102     inline int isBracketed(){return isStrategyBracketed;}
103
104     //Called for each message
105     virtual void insertMessage(MessageHolder *msg) {}
106     
107     //Called after all chares and groups have finished depositing their 
108     //messages on that processor.
109     virtual void doneInserting() {}
110
111     inline void setInstance(int instid){myInstanceID = instid;}
112     inline int getInstance(){return myInstanceID;}
113     inline int getType() {return type;}
114     inline void setType(int t) {type = t;}
115
116     inline void setDestination(int handler) {destinationHandler = handler;}
117     inline int getDestination() {return destinationHandler;}
118
119     inline void setConverseStrategy(Strategy *s){
120         converseStrategy = s;
121     }
122
123     inline Strategy * getConverseStrategy() {
124         return converseStrategy;
125     }
126
127     inline void setHigherLevel(Strategy *s) {
128         higherLevel = s;
129     }
130
131     Strategy * getHigherLevel() {
132       return higherLevel;
133     }
134
135     //This method can be used to deliver a message through the correct class
136     //when converse does not know if the message was originally sent from
137     //converse itself of from a higher level language like charm
138     virtual void deliverer(char*, int) {CmiAbort("Strategy::deliverer: If used, should be first redefined\n");};
139
140     //Each strategy must define his own Pup interface.
141     virtual void pup(PUP::er &p);
142     PUPable_decl(Strategy);
143 };
144
145 //Enables a list of strategies to be stored in a message through the
146 //pupable framework
147 class StrategyWrapper  {
148  public:
149     Strategy **s_table;
150     int nstrats;
151
152     void pup(PUP::er &p);
153 };
154 PUPmarshall(StrategyWrapper);
155
156 //Table of strategies. Each entry in the table points to a strategy.
157 //Strategies can change during the execution of the program but the
158 //StrategyTableEntry stores some persistent information for the
159 //strategy. The communication library on receiving a message, calls
160 //the strategy in this table given by the strategy id in the message.
161
162 struct StrategyTableEntry {
163     Strategy *strategy;
164     //A buffer for all strategy messages
165     CkQ<MessageHolder*> tmplist;
166     
167     int numElements;   //used by the array listener, 
168                        //could also be used for other objects
169     int elementCount;  //Count of how many elements have deposited
170                        //their data
171
172     //Used during a fence barrier at the begining or during the
173     //learning phases. Learning is only available for Charm++
174     //programs.
175     int nEndItr;       //#elements that called end iteration
176     int call_doneInserting; //All elements deposited their data
177
178     StrategyTableEntry();
179 };
180
181 typedef CkVec<StrategyTableEntry> StrategyTable;
182
183 /* Global variables needed by some strategy */
184 CsvExtern(int, pipeBcastPropagateHandle);
185 CsvExtern(int, pipeBcastPropagateHandle_frag);
186
187 #endif