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