54b26fe2f5fd28c7b4d8799ac7b9ea80c60141e2
[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   /// Time at which the last checkpoint was performed
105   double parLastCheckpointTime;
106   /* things which used to be member function statics */
107   /// optimistic and coservative GVTs
108   POSE_TimeType optGVT, conGVT;
109   int rdone;
110   /// used in PVT report reduction
111   SRentry *SRs;
112 #ifdef MEM_TEMPORAL
113   TimePool *localTimePool;
114 #endif
115
116  public:
117   /// Basic Constructor
118   PVT(void);
119   /// Migration Constructor
120   PVT(CkMigrateMessage *msg) : Group(msg) { };
121   /// PUP routine
122   void pup(PUP::er &p);
123   /// Destructor
124   ~PVT() { }
125   /// ENTRY: runs the PVT calculation and reports to GVT
126   void startPhase(prioBcMsg *m);             
127   /// ENTRY: runs the expedited PVT calculation and reports to GVT
128   void startPhaseExp(prioBcMsg *m);             
129   /// ENTRY: receive GVT estimate; wake up objects
130   /** Receives the new GVT estimate and termination flag; wakes up objects
131       for fossil collection and forward execution with new GVT estimate. */
132   void setGVT(GVTMsg *m);            
133   /// ENTRY: begin checkpoint now that quiescence has been reached
134   void beginCheckpoint(eventMsg *m);
135   /// ENTRY: resume after checkpointing, restarting, or if checkpointing doesn't occur
136   void resumeAfterCheckpoint(eventMsg *m);
137   void beginLoadbalancing(eventMsg *m);
138   void callAtSync();
139   void doneLB();
140
141   /// Returns GVT estimate
142   POSE_TimeType getGVT() { return estGVT; }    
143
144   int getSpecEventCount() { return specEventCount; }    
145   int getEventCount() { return eventCount; }    
146   void incSpecEventCount() { specEventCount++; }    
147   void incEventCount() { eventCount++; }
148   void decEventCount() { eventCount--; }
149   /// Returns termination flag
150   int done() { return simdone; }
151   /// Register poser with PVT
152   int objRegister(int arrIdx, POSE_TimeType safeTime, int sync, sim *myPtr);
153   /// Unregister poser from PVT
154   void objRemove(int pvtIdx);
155   /// Update send/recv table at timestamp
156   void objUpdate(POSE_TimeType timestamp, int sr); 
157   /// Update PVT with safeTime and send/recv table at timestamp
158   void objUpdateOVT(int pvtIdx, POSE_TimeType safeTime, POSE_TimeType ovt);
159   /// Reduction point for PVT reports
160   void reportReduce(UpdateMsg *);
161   /// Adds incoming send/recv information to a list
162   void addSR(SRentry **SRs, SRentry *e, POSE_TimeType og, int ne);
163   int getNumObjs() { return objs.getNumObjs(); }
164 };
165
166 /// GVT chare group for estimating GVT
167 /** Responsibility for GVT estimation shifts between branches after each
168     GVT invocation. */
169 class GVT : public Group { 
170 private:
171 #ifndef CMK_OPTIMIZE
172   localStat *localStats;
173 #endif
174   /// Latest GVT estimate
175   POSE_TimeType estGVT; 
176   /// Inactivity status: number of iterations since GVT has changed
177   int inactive;
178   /// Time at which GVT last went inactive
179   POSE_TimeType inactiveTime;
180   /// Number of GVT iterations since last LB run
181   int nextLBstart; 
182   /// Earliest send/recv timestamp in previous GVT invocation
183   POSE_TimeType lastEarliest;
184   /// Number of sends at lastEarliest
185   int lastSends;
186   /// Number of receives at lastEarliest
187   int lastRecvs;
188   /// Number of PVT reports expected (1 or 2)
189   int reportsExpected;
190   /* things which used to be member function static */
191   /// optimistic and coservative GVTs
192   POSE_TimeType optGVT, conGVT;
193   int done;
194   /// used to calculate GVT from PVT reports
195   SRentry *SRs;
196   int startOffset;
197 public:
198   /// Basic Constructor
199   GVT(void);
200   /// Migration Constructor
201   GVT(CkMigrateMessage *msg) : Group(msg) { };
202   /// PUP routine
203   void pup(PUP::er &p) {
204     p|estGVT; p|inactive; p|inactiveTime; p|nextLBstart;
205     p|lastEarliest; p|lastSends; p|lastRecvs; p|reportsExpected;
206     p|optGVT; p|conGVT; p|done; p|startOffset;
207
208     if (p.isUnpacking()) {
209 #ifndef CMK_OPTIMIZE
210       localStats = (localStat *)CkLocalBranch(theLocalStats);
211 #endif
212     }
213
214     if (SRs != NULL) {
215       CkAbort("ERROR: GVT member *SRs is unexpectedly not NULL\n");
216     }
217   }
218   //Use this for Ccd calls
219   //static void _runGVT(UpdateMsg *);
220   /// ENTRY: Run the GVT
221   /** Updates data fields with info from previous GVT estimation.  Fires
222       off PVT calculations on all PVT branches. */
223   void runGVT(UpdateMsg *);
224   /// ENTRY: Gathers PVT reports; calculates and broadcasts GVT to PVTs
225   void computeGVT(UpdateMsg *); 
226   /// Adds incoming send/recv information to a list
227   void addSR(SRentry **SRs, SRentry *e, POSE_TimeType og, int ne);
228 };
229
230 #endif