getting rid of the windows compile error
[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     virtual void pup(PUP::er &p);
55     PUPable_decl(MessageHolder);
56 };
57
58 #define CONVERSE_STRATEGY 0     //The strategy works for converse programs
59 #define NODEGROUP_STRATEGY 1    //Node group level optimizations 
60 #define GROUP_STRATEGY 2        //Charm Processor level optimizations
61 #define ARRAY_STRATEGY 3        //Array level optimizations
62
63 //Class that defines the entry methods that a Converse level strategy
64 //must define. To write a new strategy inherit from this class and
65 //define the virtual methods.  Every strategy can also define its own
66 //constructor and have any number of arguments. Also call the parent
67 //class methods in the virtual methods.
68
69 class Strategy : public PUP::able{
70  protected:
71     int type;
72     int isStrategyBracketed;
73     int myInstanceID;
74
75     //Charm strategies for modularity may have converse strategies in
76     //them.  For the code to work in both Charm and converse, this
77     //variable can be used.    
78     Strategy *converseStrategy;
79
80  public:
81     Strategy();
82     Strategy(CkMigrateMessage *m) : PUP::able(m) {
83         converseStrategy = this;
84     }
85
86     void setBracketed(){isStrategyBracketed = 1;}
87     int isBracketed(){return isStrategyBracketed;}
88
89     //Called for each message
90     virtual void insertMessage(MessageHolder *msg) {}
91     
92     //Called after all chares and groups have finished depositing their 
93     //messages on that processor.
94     virtual void doneInserting() {}
95
96     void setInstance(int instid){myInstanceID = instid;}
97     int getInstance(){return myInstanceID;}
98     int getType() {return type;}
99     void setType(int t) {type = t;}
100
101     void setConverseStrategy(Strategy *s){
102         converseStrategy = s;
103     }
104
105     Strategy * getConverseStrategy() {
106         return converseStrategy;
107     }
108
109     //Each strategy must define his own Pup interface.
110     virtual void pup(PUP::er &p);
111     PUPable_decl(Strategy);
112 };
113
114 //Enables a list of strategies to be stored in a message through the
115 //pupable framework
116 class StrategyWrapper  {
117  public:
118     Strategy **s_table;
119     int nstrats;
120
121     void pup(PUP::er &p);
122 };
123 PUPmarshall(StrategyWrapper);
124
125 //Table of strategies. Each entry in the table points to a strategy.
126 //Strategies can change during the execution of the program but the
127 //StrategyTableEntry stores some persistent information for the
128 //strategy. The communication library on receiving a message, calls
129 //the strategy in this table given by the strategy id in the message.
130
131 struct StrategyTableEntry {
132     Strategy *strategy;
133     //A buffer for all strategy messages
134     CkQ<MessageHolder*> tmplist;
135     
136     int numElements;   //used by the array listener, 
137                        //could also be used for other objects
138     int elementCount;  //Count of how many elements have deposited
139                        //their data
140
141     //Used during a fence barrier at the begining or during the
142     //learning phases. Learning is only available for Charm++
143     //programs.
144     int nEndItr;       //#elements that called end iteration
145     int call_doneInserting; //All elements deposited their data
146
147     StrategyTableEntry();
148 };
149
150 typedef CkVec<StrategyTableEntry> StrategyTable;
151
152 #endif