Add support for Charm++'s change to use 64 bit ID for load balancing
[namd.git] / src / LdbCoordinator.h
1 /**
2 ***  Copyright (c) 1995, 1996, 1997, 1998, 1999, 2000 by
3 ***  The Board of Trustees of the University of Illinois.
4 ***  All rights reserved.
5 **/
6
7 /*****************************************************************************
8  * $Source: /home/cvs/namd/cvsroot/namd2/src/LdbCoordinator.h,v $
9  * $Author: jim $
10  * $Date: 2013/09/06 19:11:37 $
11  * $Revision: 1.47 $
12  *****************************************************************************/
13
14 #ifndef LDBCOORDINATOR_H
15 #define LDBCOORDINATOR_H
16
17 #include <stdio.h>
18
19 #include <charm++.h>
20 #include <LBDatabase.h>
21
22 #include "NamdTypes.h"
23 #include "BOCgroup.h"
24 #include "LdbCoordinator.decl.h"
25
26 /// In the new 64-bit id case defining LdbId as CmiUInt8,
27 /// the first 32 bits store the object's index and
28 /// the second 32 bits store the type.
29 ///
30 /// In the old int[4] id case defining LdbId as LDObjid,
31 /// element 0 stores the object's index, element 1 stores the type,
32 /// and elements 2 and 3 are unused.
33 #if CMK_LBID_64BIT
34 typedef CmiUInt8 LdbId;
35 #else
36 typedef LDObjid LdbId;
37 #endif
38
39 inline const int& LdbIdField(const LdbId& id, const int index) {
40 #if CMK_LBID_64BIT
41   return *(((int*)&id) + index);
42 #else
43   return id.id[index];
44 #endif
45 }
46
47 inline int& LdbIdField(LdbId& id, const int index) {
48 #if CMK_LBID_64BIT
49   return *(((int*)&id) + index);
50 #else
51   return id.id[index];
52 #endif
53 }
54
55 /// Define the types encoded into the load balancing id.
56 /// Use negative numbers because the nonbonded/self types
57 /// are represented with the leading patch ID for that compute,
58 /// when available.
59 enum {
60   NONBONDED_OR_SELF_TYPE = -1,  ///< represents nonbonded or self compute
61   PATCH_TYPE = -2,              ///< represents a patch
62   BONDED_TYPE = -3              ///< represents bonded compute
63 };
64
65 class PatchMap;
66 class ComputeMap;
67 class Controller;
68 class Sequencer;
69 class computeInfo;
70 class patchInfo;
71 class processorInfo;
72
73 enum {LDB_PATCHES = 4096};
74 enum {LDB_COMPUTES = 16384};
75 enum {COMPUTEMAX = 16384};
76 enum {PATCHMAX = 4096};
77 enum {PROCESSORMAX = 512};
78
79 void LdbCoordinator_initproc();
80
81 class LdbCoordinator : public CBase_LdbCoordinator
82 {
83 public:
84   LdbCoordinator();
85   ~LdbCoordinator(void);
86   static LdbCoordinator *Object()  { 
87     return CkpvAccess(LdbCoordinator_instance); 
88   }
89
90   void initialize(PatchMap *pmap, ComputeMap *cmap, int reinit=0);
91   void createLoadBalancer();
92   void patchLoad(PatchID id, int nAtoms, int timestep);
93
94   void startWork(const LDObjHandle &handle) {  // start timer
95     theLbdb->ObjectStart(handle);
96   }
97   void pauseWork(const LDObjHandle &handle) {  // stop timer only
98     theLbdb->ObjectStop(handle);
99   }
100   void skipWork(const LDObjHandle &handle) {  // increment counter only
101     nComputesReported++;
102   }
103   void endWork(const LDObjHandle &handle) {  // both
104     theLbdb->ObjectStop(handle);
105     nComputesReported++;
106   }
107
108   void rebalance(Sequencer *seq, PatchID id);
109   void rebalance(Controller *seq);
110   void nodeDone(CkReductionMsg *);
111   void updateComputesReady();
112   void barrier(void);
113   void resume(void);
114   void resumeReady(CkQdMsg *msg);
115   void resume2(void);
116   int getNumStepsToRun(void) { return numStepsToRun; }
117   static void staticMigrateFn(LDObjHandle handle, int dest);
118   static void staticStatsFn(LDOMHandle h, int state);
119   static void staticQueryEstLoadFn(LDOMHandle h);
120   static void staticReceiveAtSync(void* data);
121   static void staticResumeFromSync(void* data);
122   void ReceiveAtSync(void);
123   void Migrate(LDObjHandle handle, int dest);
124   void RecvMigrate(LdbMigrateMsg*);
125   void ExpectMigrate(LdbMigrateMsg*);
126   void ResumeFromSync(void);
127
128 public:
129   void ExecuteMigrations(void);
130   void awakenSequencers(void);
131   int requiredProxies(PatchID id, int []);
132   void printRequiredProxies(PatchID id, FILE *fp);
133   void printLocalLdbReport(void);
134
135   int stepsPerLdbCycle;
136   int nLocalComputes;
137   int nLocalPatches;
138   int nPatchesReported;
139   int nPatchesExpected;
140   int nComputesReported;
141   int nComputesExpected;
142   int controllerReported;
143   int controllerExpected;
144   int nStatsMessagesReceived;
145   int nStatsMessagesExpected;
146   ComputeMap *computeMap;
147   PatchMap *patchMap;
148   int *patchNAtoms;
149   int  nPatches;
150   Controller *controllerThread;
151   Sequencer **sequencerThreads;
152
153   int ldbCycleNum;
154   int numStepsToRun;    // tells Controller how many time steps to run 
155                         // before another load balancing
156   int firstLdbStep;
157   int totalStepsDone;   // keeps a count of the total number of
158                         // time steps to stop load balancing
159   int takingLdbData;
160
161   FILE *ldbStatsFP;
162   computeInfo *computeArray;
163   patchInfo *patchArray;
164   processorInfo *processorArray;
165   LBDatabase *theLbdb;
166   LDOMid myOMid;
167   LDOMHandle myHandle;
168   LdbMigrateMsg *migrateMsgs;
169   int numComputes;
170   int nRegisteredObjs;
171   LDBarrierClient ldBarrierHandle;
172   int reg_all_objs;
173   LDObjHandle* patchHandles;
174
175   void sendCollectLoads(CollectLoadsMsg*);
176   void collectLoads(CollectLoadsMsg*);
177 private:
178   int collPes;
179   int reverted;
180   int initTotalProxies;
181   int finalTotalProxies;
182   int initMaxPeProxies;
183   int finalMaxPeProxies;
184   int initMaxPatchProxies;
185   int finalMaxPatchProxies;
186   double initTime;
187   double finalTime;
188   double initMemory;
189   double finalMemory;
190   double initAvgPeLoad;
191   double finalAvgPeLoad;
192   double initMaxPeLoad;
193   double finalMaxPeLoad;
194 };
195
196 class CollectLoadsMsg : public CMessage_CollectLoadsMsg {
197 public:
198   int firstPe;
199   int lastPe;
200   int reverted;
201   int initTotalProxies;
202   int finalTotalProxies;
203   int initMaxPeProxies;
204   int finalMaxPeProxies;
205   int initMaxPatchProxies;
206   int finalMaxPatchProxies;
207   double initTime;
208   double finalTime;
209   double initMemory;
210   double finalMemory;
211   double initAvgPeLoad;
212   double finalAvgPeLoad;
213   double initMaxPeLoad;
214   double finalMaxPeLoad;
215   char strategyName[16];
216 };
217
218 class LdbMigrateMsg : public CMessage_LdbMigrateMsg
219 {
220 public:
221   LDObjHandle handle;
222   int from;
223   int to;
224   LdbMigrateMsg *next;
225 };
226
227
228 #endif // LDBCOORDINATOR_H
229