added a command line option +lb_gvt_pose to set the gvt intervals between load balancing.
[charm.git] / src / libs / ck-libs / pose / gvt.h
1 /// Global Virtual Time estimation for POSE
2 /** Implements the Global Virtual Time (GVT) algorithm; provides chare
3     groups PVT and GVT. Objects interact with the local PVT branch.
4     PVT branches summarize object info and report to the single
5     floating GVT object, which broadcasts results to all PVT branches. */
6
7 #ifndef GVT_H
8 #define GVT_H
9 #include "gvt.decl.h"
10
11 /// synchronization strategies
12 #define OPTIMISTIC 0
13 #define CONSERVATIVE 1
14
15 /// Global handles ThePVT and TheGVT are declared in gvt.C, used everywhere
16 extern CkGroupID ThePVT;  
17 extern CkGroupID TheGVT;
18
19 class SRtable;  // from srtable.h
20 class SRentry;  // from srtable.h
21
22 /// Message to send info to GVT 
23 /** PVT sends processor virtual time and send/recv information to GVT.  
24     GVT also sends info to next GVT index for next GVT invocation. */
25 class UpdateMsg : public CMessage_UpdateMsg {
26 public:
27   /// PVT of local optimistic objects
28   /** Used to send estimated GVT from one GVT invocation to next */
29   POSE_TimeType optPVT;
30   /// PVT of local conservative objects
31   POSE_TimeType conPVT;
32   /// Max timestamp in SR table
33   POSE_TimeType maxSR;
34   /// # sends/recvs at particular timestamps <= PVT
35   SRentry *SRs;
36   /// Count of entries in SRs
37   int numEntries;
38   /// Inactive status (GVT only)
39   int inactive;
40   /// Inactive time (GVT only)
41   POSE_TimeType inactiveTime;
42   /// Iterations of GVT since last LB (GVT only)
43   int nextLB;
44   /// Flag used by runGVT to call computeGVT indicating readiness
45   int runGVTflag;
46 };
47
48 /// Message to send GVT estimate back to PVT
49 class GVTMsg : public CMessage_GVTMsg {
50 public:
51   /// GVT estimate
52   POSE_TimeType estGVT;
53   /// Termination flag
54   int done;
55 };
56
57 /// Prioritized int msg; used to force GVT calculations
58 class prioBcMsg : public CMessage_prioBcMsg {
59 public:
60   int bc;
61 };
62
63 /// PVT chare group for computing local processor virtual time 
64 /** Keeps track of local sends/recvs and computes processor virtual time.
65     Interacts with GVT to obtain new estimate and invokes fossil 
66     collection and forward execution on objects with new estimate. */
67 class PVT : public Group {  
68  private:
69 #ifndef CMK_OPTIMIZE
70   localStat *localStats;
71 #endif
72   /// PVT of local optimistic posers
73   POSE_TimeType optPVT;
74   /// PVT of local conservative posers
75   POSE_TimeType conPVT;
76   /// Last GVT estimate
77   POSE_TimeType estGVT;       
78   /// Last reported PVT estimate
79   POSE_TimeType repPVT;       
80   /// Simulation termination flag
81   int simdone;
82   /// Minimum send/recv timestamp in this iteration
83   POSE_TimeType iterMin;
84   /// Flag to indicate waiting for first send/recv of next iteration
85   /** Used to indicate when to restructure the SendsAndRecvs table */
86   int waitForFirst;
87   /// Table to store send/recv timestamps
88   SRtable *SendsAndRecvs;            
89   /// List of objects registered with this PVT branch
90   pvtObjects objs;           
91   /// reduction-related vars
92   int reportTo, reportsExpected, reportReduceTo, reportEnd;
93   /// where the centralized GVT goes
94   int gvtTurn;
95   int specEventCount, eventCount;
96   /// startPhase active flag
97   int startPhaseActive;
98   /// starting time of the simulation
99   double parStartTime;
100   /// indicates if checkpointing is in progress
101   int parCheckpointInProgress;
102   /// GVT at which the last checkpoint was performed
103   POSE_TimeType parLastCheckpointGVT;
104   /// indicates if load balancing is in progress
105   int parLBInProgress;
106   /// GVT at which the last load balancing was performed
107   POSE_TimeType parLastLBGVT;
108   /// Time at which the last checkpoint was performed
109   double parLastCheckpointTime;
110   /* things which used to be member function statics */
111   /// optimistic and coservative GVTs
112   POSE_TimeType optGVT, conGVT;
113   int rdone;
114   /// used in PVT report reduction
115   SRentry *SRs;
116 #ifdef MEM_TEMPORAL
117   TimePool *localTimePool;
118 #endif
119
120  public:
121   /// Basic Constructor
122   PVT(void);
123   /// Migration Constructor
124   PVT(CkMigrateMessage *msg) : Group(msg) { };
125   /// PUP routine
126   void pup(PUP::er &p);
127   /// Destructor
128   ~PVT() { }
129   /// ENTRY: runs the PVT calculation and reports to GVT
130   void startPhase(prioBcMsg *m);             
131   /// ENTRY: runs the expedited PVT calculation and reports to GVT
132   void startPhaseExp(prioBcMsg *m);             
133   /// ENTRY: receive GVT estimate; wake up objects
134   /** Receives the new GVT estimate and termination flag; wakes up objects
135       for fossil collection and forward execution with new GVT estimate. */
136   void setGVT(GVTMsg *m);            
137   /// ENTRY: begin checkpoint now that quiescence has been reached
138   void beginCheckpoint(eventMsg *m);
139   /// ENTRY: resume after checkpointing, restarting, or if checkpointing doesn't occur
140   void resumeAfterCheckpoint(eventMsg *m);
141   void beginLoadbalancing(eventMsg *m);
142   void resumeAfterLB(eventMsg *m);
143   void callAtSync();
144   void doneLB();
145
146   /// Returns GVT estimate
147   POSE_TimeType getGVT() { return estGVT; }    
148
149   int getSpecEventCount() { return specEventCount; }    
150   int getEventCount() { return eventCount; }    
151   void incSpecEventCount() { specEventCount++; }    
152   void incEventCount() { eventCount++; }
153   void decEventCount() { eventCount--; }
154   /// Returns termination flag
155   int done() { return simdone; }
156   /// Register poser with PVT
157   int objRegister(int arrIdx, POSE_TimeType safeTime, int sync, sim *myPtr);
158   /// Unregister poser from PVT
159   void objRemove(int pvtIdx);
160   /// Update send/recv table at timestamp
161   void objUpdate(POSE_TimeType timestamp, int sr); 
162   /// Update PVT with safeTime and send/recv table at timestamp
163   void objUpdateOVT(int pvtIdx, POSE_TimeType safeTime, POSE_TimeType ovt);
164   /// Reduction point for PVT reports
165   void reportReduce(UpdateMsg *);
166   /// Adds incoming send/recv information to a list
167   void addSR(SRentry **SRs, SRentry *e, POSE_TimeType og, int ne);
168   int getNumObjs() { return objs.getNumObjs(); }
169 };
170
171 /// GVT chare group for estimating GVT
172 /** Responsibility for GVT estimation shifts between branches after each
173     GVT invocation. */
174 class GVT : public Group { 
175 private:
176 #ifndef CMK_OPTIMIZE
177   localStat *localStats;
178 #endif
179   /// Latest GVT estimate
180   POSE_TimeType estGVT; 
181   /// Inactivity status: number of iterations since GVT has changed
182   int inactive;
183   /// Time at which GVT last went inactive
184   POSE_TimeType inactiveTime;
185   /// Number of GVT iterations since last LB run
186   int nextLBstart; 
187   /// Earliest send/recv timestamp in previous GVT invocation
188   POSE_TimeType lastEarliest;
189   /// Number of sends at lastEarliest
190   int lastSends;
191   /// Number of receives at lastEarliest
192   int lastRecvs;
193   /// Number of PVT reports expected (1 or 2)
194   int reportsExpected;
195   /* things which used to be member function static */
196   /// optimistic and coservative GVTs
197   POSE_TimeType optGVT, conGVT;
198   int done;
199   /// used to calculate GVT from PVT reports
200   SRentry *SRs;
201   int startOffset;
202 public:
203   /// Basic Constructor
204   GVT(void);
205   /// Migration Constructor
206   GVT(CkMigrateMessage *msg) : Group(msg) { };
207   /// PUP routine
208   void pup(PUP::er &p) {
209     p|estGVT; p|inactive; p|inactiveTime; p|nextLBstart;
210     p|lastEarliest; p|lastSends; p|lastRecvs; p|reportsExpected;
211     p|optGVT; p|conGVT; p|done; p|startOffset;
212
213     if (p.isUnpacking()) {
214 #ifndef CMK_OPTIMIZE
215       localStats = (localStat *)CkLocalBranch(theLocalStats);
216 #endif
217     }
218
219     if (SRs != NULL) {
220       CkAbort("ERROR: GVT member *SRs is unexpectedly not NULL\n");
221     }
222   }
223   //Use this for Ccd calls
224   //static void _runGVT(UpdateMsg *);
225   /// ENTRY: Run the GVT
226   /** Updates data fields with info from previous GVT estimation.  Fires
227       off PVT calculations on all PVT branches. */
228   void runGVT(UpdateMsg *);
229   /// ENTRY: Gathers PVT reports; calculates and broadcasts GVT to PVTs
230   void computeGVT(UpdateMsg *); 
231   /// Adds incoming send/recv information to a list
232   void addSR(SRentry **SRs, SRentry *e, POSE_TimeType og, int ne);
233 };
234
235 #endif