change Ckpv to Cpv in conv-com
[charm.git] / src / conv-com / convcomlibstrategy.C
1 /**
2    @addtogroup ComlibConverseStrategy
3
4    @{
5    @file
6    @brief Implementations of the classes in convcomlibstrategy.C
7 */
8
9 #include "convcomlibmanager.h"
10
11 Strategy::Strategy() : PUP::able() {
12   ComlibPrintf("Creating new strategy (Strategy constructor)\n");
13     myHandle = CkpvAccess(conv_com_object).insertStrategy(this);
14     type = CONVERSE_STRATEGY;
15     //converseStrategy = this;
16     //higherLevel = this;
17     isStrategyBracketed = 0;
18     //destinationHandler = 0;
19 };
20
21 //Each strategy must define his own Pup interface.
22 void Strategy::pup(PUP::er &p){ 
23     
24   //PUP::able::pup(p);
25
26     p | isStrategyBracketed;
27     p | type;
28     //p | destinationHandler;
29     p | myHandle;
30
31     /*if (p.isUnpacking()) {
32       converseStrategy = this;
33       higherLevel = this;
34     }*/
35 }
36
37 //Message holder functions. Message holder is a wrapper around a
38 //message. Has other useful data like destination processor list for a
39 //multicast etc.
40
41 void MessageHolder::pup(PUP::er &p) {
42     //PUP::able::pup(p);
43
44     p | dest_proc;
45     p | isDummy;
46     p | size;
47     p | npes;
48
49     if(p.isUnpacking()) {
50         data = (char *)CmiAlloc(size);
51         
52         if(npes >0)
53             pelist = new int[npes];
54     }
55
56     p(data, size);
57     if(npes > 0)
58         p(pelist, npes);    
59     else
60         pelist = 0;
61 }
62
63 StrategyWrapper::StrategyWrapper(int count) {
64   nstrats = count;
65   strategy = new Strategy* [nstrats];
66   position = new int[nstrats];
67   replace = new CmiBool[nstrats];
68 }
69
70 StrategyWrapper::~StrategyWrapper() {
71   delete[] strategy;
72   delete[] position;
73   delete[] replace;
74 }
75
76 void StrategyWrapper::pup (PUP::er &p) {
77   p | nstrats;
78   //p | total_nstrats;
79
80   if(p.isUnpacking()) {
81     strategy = new Strategy* [nstrats];
82     position = new int[nstrats];
83     replace = new CmiBool[nstrats];
84   }
85   
86   for(int count = 0; count < nstrats; ++count) {
87     p | strategy[count];
88     p | position[count];
89     p | replace[count];
90   }
91 }
92
93
94 StrategyTableEntry::StrategyTableEntry() {
95     lastKnownIteration = -1000;
96     strategy = NULL;
97     isNew = 0;
98     isReady = 0;
99     // WARNING: This constructor is called before CkMyPe() returns the correct results
100     errorMode = NORMAL_MODE;
101     errorModeServer = STARTUP_MODE_SERVER; 
102     discoveryMode = NORMAL_DISCOVERY_MODE;
103     bracketedSetupFinished = 0;
104
105     numBufferReleaseReady = 0;
106
107     numElements = 0;
108     nBeginItr = 0;
109     nEndItr = 0;
110     call_doneInserting = 0; 
111
112     // values used during bracketed error/confirm mode
113     nEndSaved = 0;
114     totalEndCounted = 0;
115     nProcSync = 0;
116
117     peConfirmCounter=0;
118     total=0; 
119         
120     // initialize values used during the discovery process
121     peList = NULL;
122 }
123
124 //called during learning, when all fields except
125 //strategy need to be zeroed out
126 void StrategyTableEntry::reset() {
127     numElements = 0;   //used by the array listener, 
128                        //could also be used for other objects
129     //elementCount = 0;  //Count of how many elements have deposited
130                        //their data
131     nEndItr = 0;       //#elements that called end iteration
132     call_doneInserting = 0;
133 }
134
135
136 char *StrategyTableEntry::errorModeString(){
137   switch(errorMode) {
138   case NORMAL_MODE:
139     return "NORMAL_MODE       ";
140   case ERROR_MODE:
141     return "ERROR_MODE        ";
142   case CONFIRM_MODE:
143     return "CONFIRM_MODE      ";
144   case ERROR_FIXED_MODE:
145     return "ERROR_FIXED_MODE  ";
146   default:
147     return "Unknown Error Mode";
148   }
149 }
150
151
152 char *StrategyTableEntry::errorModeServerString(){
153   switch(errorModeServer) {
154   case STARTUP_MODE_SERVER:
155     return "STARTUP_MODE_SERVER    ";
156   case NORMAL_MODE_SERVER:
157     return "NORMAL_MODE_SERVER     ";
158   case ERROR_MODE_SERVER:
159     return "ERROR_MODE_SERVER      ";
160   case CONFIRM_MODE_SERVER:
161     return "CONFIRM_MODE_SERVER    ";
162   case ERROR_FIXED_MODE_SERVER:
163     return "ERROR_FIXED_MODE_SERVER";
164   case NON_SERVER_MODE_SERVER:
165     return "NON_SERVER_MODE_SERVER ";
166   default:
167     return "Unknown Server Error Mode";
168   }
169 }
170
171 char *StrategyTableEntry::discoveryModeString(){
172   switch(discoveryMode) {
173   case NORMAL_DISCOVERY_MODE:
174     return "NORMAL_DISCOVERY_MODE  ";
175   case STARTED_DISCOVERY_MODE: 
176     return "STARTED_DISCOVERY_MODE ";
177   case FINISHED_DISCOVERY_MODE:
178     return "FINISHED_DISCOVERY_MODE";
179   default:
180     return "Unknown Discovery Mode ";
181   }
182 }
183
184
185
186
187
188
189 //PUPable_def(Strategy);
190 PUPable_def(MessageHolder);
191
192 //CsvDeclare(int, pipeBcastPropagateHandle);
193 //CsvDeclare(int, pipeBcastPropagateHandle_frag);
194
195 /*@}*/