e25bed335b5724288d2e9e2b471d6be7023d0d64
[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 class PatchMap;
27 class ComputeMap;
28 class Controller;
29 class Sequencer;
30 class computeInfo;
31 class patchInfo;
32 class processorInfo;
33
34 enum {LDB_PATCHES = 4096};
35 enum {LDB_COMPUTES = 16384};
36 enum {COMPUTEMAX = 16384};
37 enum {PATCHMAX = 4096};
38 enum {PROCESSORMAX = 512};
39
40 void LdbCoordinator_initproc();
41
42 class LdbCoordinator : public CBase_LdbCoordinator
43 {
44 public:
45   LdbCoordinator();
46   ~LdbCoordinator(void);
47   static LdbCoordinator *Object()  { 
48     return CkpvAccess(LdbCoordinator_instance); 
49   }
50
51   void initialize(PatchMap *pmap, ComputeMap *cmap, int reinit=0);
52   void createLoadBalancer();
53   void patchLoad(PatchID id, int nAtoms, int timestep);
54
55   void startWork(const LDObjHandle &handle) {  // start timer
56     theLbdb->ObjectStart(handle);
57   }
58   void pauseWork(const LDObjHandle &handle) {  // stop timer only
59     theLbdb->ObjectStop(handle);
60   }
61   void skipWork(const LDObjHandle &handle) {  // increment counter only
62     nComputesReported++;
63   }
64   void endWork(const LDObjHandle &handle) {  // both
65     theLbdb->ObjectStop(handle);
66     nComputesReported++;
67   }
68
69   void rebalance(Sequencer *seq, PatchID id);
70   void rebalance(Controller *seq);
71   void nodeDone(CkReductionMsg *);
72   void updateComputesReady();
73   void barrier(void);
74   void resume(void);
75   void resumeReady(CkQdMsg *msg);
76   void resume2(void);
77   int getNumStepsToRun(void) { return numStepsToRun; }
78   static void staticMigrateFn(LDObjHandle handle, int dest);
79   static void staticStatsFn(LDOMHandle h, int state);
80   static void staticQueryEstLoadFn(LDOMHandle h);
81   static void staticReceiveAtSync(void* data);
82   static void staticResumeFromSync(void* data);
83   void ReceiveAtSync(void);
84   void Migrate(LDObjHandle handle, int dest);
85   void RecvMigrate(LdbMigrateMsg*);
86   void ExpectMigrate(LdbMigrateMsg*);
87   void ResumeFromSync(void);
88
89 public:
90   void ExecuteMigrations(void);
91   void awakenSequencers(void);
92   int requiredProxies(PatchID id, int []);
93   void printRequiredProxies(PatchID id, FILE *fp);
94   void printLocalLdbReport(void);
95
96   int stepsPerLdbCycle;
97   int nLocalComputes;
98   int nLocalPatches;
99   int nPatchesReported;
100   int nPatchesExpected;
101   int nComputesReported;
102   int nComputesExpected;
103   int controllerReported;
104   int controllerExpected;
105   int nStatsMessagesReceived;
106   int nStatsMessagesExpected;
107   ComputeMap *computeMap;
108   PatchMap *patchMap;
109   int *patchNAtoms;
110   int  nPatches;
111   Controller *controllerThread;
112   Sequencer **sequencerThreads;
113
114   int ldbCycleNum;
115   int numStepsToRun;    // tells Controller how many time steps to run 
116                         // before another load balancing
117   int firstLdbStep;
118   int totalStepsDone;   // keeps a count of the total number of
119                         // time steps to stop load balancing
120   int takingLdbData;
121
122   FILE *ldbStatsFP;
123   computeInfo *computeArray;
124   patchInfo *patchArray;
125   processorInfo *processorArray;
126   LBDatabase *theLbdb;
127   LDOMid myOMid;
128   LDOMHandle myHandle;
129   LdbMigrateMsg *migrateMsgs;
130   int numComputes;
131   int nRegisteredObjs;
132   LDBarrierClient ldBarrierHandle;
133   int reg_all_objs;
134   LDObjHandle* patchHandles;
135
136   void sendCollectLoads(CollectLoadsMsg*);
137   void collectLoads(CollectLoadsMsg*);
138 private:
139   int collPes;
140   int reverted;
141   int initTotalProxies;
142   int finalTotalProxies;
143   int initMaxPeProxies;
144   int finalMaxPeProxies;
145   int initMaxPatchProxies;
146   int finalMaxPatchProxies;
147   double initTime;
148   double finalTime;
149   double initMemory;
150   double finalMemory;
151   double initAvgPeLoad;
152   double finalAvgPeLoad;
153   double initMaxPeLoad;
154   double finalMaxPeLoad;
155 };
156
157 class CollectLoadsMsg : public CMessage_CollectLoadsMsg {
158 public:
159   int firstPe;
160   int lastPe;
161   int reverted;
162   int initTotalProxies;
163   int finalTotalProxies;
164   int initMaxPeProxies;
165   int finalMaxPeProxies;
166   int initMaxPatchProxies;
167   int finalMaxPatchProxies;
168   double initTime;
169   double finalTime;
170   double initMemory;
171   double finalMemory;
172   double initAvgPeLoad;
173   double finalAvgPeLoad;
174   double initMaxPeLoad;
175   double finalMaxPeLoad;
176   char strategyName[16];
177 };
178
179 class LdbMigrateMsg : public CMessage_LdbMigrateMsg
180 {
181 public:
182   LDObjHandle handle;
183   int from;
184   int to;
185   LdbMigrateMsg *next;
186 };
187
188
189 #endif // LDBCOORDINATOR_H
190