cleanup
[charm.git] / src / ck-ldb / MetaBalancer.h
1 /**
2  * \addtogroup CkLdb
3 */
4 /*@{*/
5
6 #ifndef METABALANCER_H
7 #define METABALANCER_H
8
9 #include "LBDatabase.h"
10
11 #include <vector>
12
13 #include "MetaBalancer.decl.h"
14
15 extern CkGroupID _metalb;
16 extern CkGroupID _metalbred;
17
18 CkpvExtern(int, metalbInited);
19
20 void _MetaLBInit();
21
22 // main chare
23 class MetaLBInit : public Chare {
24   public:
25     MetaLBInit(CkArgMsg*);
26     MetaLBInit(CkMigrateMessage *m):Chare(m) {}
27 };
28
29 class MetaBalancer : public CBase_MetaBalancer {
30 public:
31   MetaBalancer(void) { init(); }
32   MetaBalancer(CkMigrateMessage *m) : CBase_MetaBalancer(m) { init(); }
33   ~MetaBalancer()  {}
34  
35 private:
36   void init();
37   MetaBalancerRedn* metaRdnGroup;
38
39 public:
40   inline static MetaBalancer * Object() {
41     return CkpvAccess(metalbInited)?(MetaBalancer *)CkLocalBranch(_metalb):NULL;
42   }
43
44   static void initnodeFn(void);
45
46   void pup(PUP::er& p);
47
48   void ResumeClients();
49
50   void ResetAdaptive();
51   int get_iteration();
52   int get_finished_iteration();
53   bool AddLoad(int iteration, double load);
54   void ReceiveMinStats(CkReductionMsg *);
55   void TriggerSoon(int iteration_no, double imbalance_ratio, double tolerate_imb);
56   void LoadBalanceDecision(int, int);
57   void LoadBalanceDecisionFinal(int, int);
58   void ReceiveIterationNo(int); // Receives the current iter no
59   static void periodicCall(void *ad);
60   static void checkForNoObj(void *ad);
61   void HandleAdaptiveNoObj();
62   void RegisterNoObjCallback(int index);
63   void TriggerAdaptiveReduction();
64
65   bool generatePlan(int& period, double& ratio_at_t);
66   bool getLineEq(double new_load_percent, double& aslope, double& ac,
67       double& mslope, double& mc);
68   bool getPeriodForLinear(double a, double b, double c, int& period);
69   bool getPeriodForStrategy(double new_load, double overhead_percent,
70       int& period, double& ratio_at_t);
71   int getPredictedLBPeriod(bool& is_tentative);
72
73   bool isStrategyComm();
74
75   void UpdateAfterLBData(int is_lb_refine, double lb_max, double lb_avg, double
76       local_comm, double remote_comm);
77
78   void UpdateAfterLBData(double max_load, double max_cpu, double avg_load);
79   void UpdateAfterLBComm(double alpha_beta_cost);
80   void GetPrevLBData(int& lb_type, double& lb_max_avg_ratio, double&
81       local_remote_comm_ratio);
82   void GetLBDataForLB(int lb_type, double& lb_max_avg_ratio, double&
83       local_remote_comm_ratio);
84
85   void SetMigrationCost(double lb_migration_cost);
86   void SetStrategyCost(double lb_strategy_cost);
87
88 private:
89   //CProxy_MetaBalancer thisProxy;
90   LBDatabase* lbdatabase;
91   std::vector<double> total_load_vec;
92   // Keeps track of how many local chares contributed
93   std::vector<int> total_count_vec;
94   std::vector<int> lbdb_no_obj_callback;
95
96   double prev_idle;
97   double alpha_beta_cost_to_load;
98   int is_prev_lb_refine;
99
100   struct AdaptiveData {
101     double iteration;
102     double max_load;
103     double avg_load;
104     double utilization;
105     double idle_time;
106   };
107
108   struct AdaptiveMetaBalancer {
109     CkVec<AdaptiveData> history_data;
110     int lb_iter_no;
111   } adaptive_lbdb;
112
113   struct AdaptiveLBInfo {
114     AdaptiveLBInfo() {
115       max_avg_ratio = 1;
116       remote_local_ratio = 1;
117     }
118     double max_avg_ratio;
119     double remote_local_ratio;
120   };
121
122   // TODO: Separate out the datastructure required by just the central and on all
123   // processors
124   struct AdaptiveLBStructure {
125     int tentative_period;
126     int final_lb_period;
127     // This is based on the linear extrapolation
128     int lb_calculated_period;
129     // Current maximum iteration no of any chare on this processor
130     int lb_iteration_no;
131     // This corresponds to the last iteration that was contributed
132     int finished_iteration_no;
133     // This is set when all the processor sends the maximum iteration no
134     int global_max_iter_no;
135     // This keeps track of what was the max iteration no we had previously
136     // received. TODO: Mostly global_max_iter_no should be sufficied.
137     int tentative_max_iter_no;
138     // true indicates it is in Inform->ReceiveMaxIter->FinalLBPeriod stage.
139     bool in_progress;
140     double lb_strategy_cost;
141     double lb_migration_cost;
142     bool doCommStrategy;
143     int lb_msg_send_no;
144     int lb_msg_recv_no;
145     // Total AtSync calls from all the chares residing on the processor
146     int total_syncs_called;
147     int last_lb_type;
148     AdaptiveLBInfo greedy_info;
149     AdaptiveLBInfo refine_info;
150     AdaptiveLBInfo comm_info;
151     AdaptiveLBInfo comm_refine_info;
152     AdaptiveLBInfo info_first_iter;
153   } adaptive_struct;
154
155 public:
156   bool lb_in_progress;
157
158 };
159
160 class MetaBalancerRedn : public CBase_MetaBalancerRedn {
161   public:
162     MetaBalancerRedn(void) {init();}
163     MetaBalancerRedn(CkMigrateMessage *m) : CBase_MetaBalancerRedn(m)  {init();}
164     ~MetaBalancerRedn()  {}
165     void pup(PUP::er& p);
166     void ReceiveIterNo(int max_iter);
167     void getMaxIter(int);
168
169   private:
170     MetaBalancer* metabalancer;
171     void init();
172 };
173
174 inline MetaBalancer* MetaBalancerObj() { return MetaBalancer::Object(); }
175
176 #endif /* LDATABASE_H */
177
178 /*@}*/