Refactoring
[charm.git] / src / ck-ldb / MetaBalancer.h
1 /**
2  * \addtogroup CkLdb
3 */
4 /*@{*/
5
6 #ifndef METABALANCER_H
7 #define METABALANCER_H
8
9
10 //#include <charm++.h>
11 //#include "ckreduction.h" 
12
13 //#include "lbdb.h"
14 //#include "LBDBManager.h"
15 //#include "lbdb++.h"
16 #include "LBDatabase.h"
17
18 #include <vector>
19
20 #include "MetaBalancer.decl.h"
21
22 extern CkGroupID _metalb;
23
24 CkpvExtern(int, metalbInited);
25
26 void _MetaLBInit();
27
28 // main chare
29 class MetaLBInit : public Chare {
30   public:
31     MetaLBInit(CkArgMsg*);
32     MetaLBInit(CkMigrateMessage *m):Chare(m) {}
33 };
34
35 class MetaBalancer : public CBase_MetaBalancer {
36 public:
37   MetaBalancer(void)  { init(); }
38   MetaBalancer(CkMigrateMessage *m)  { init(); }
39   ~MetaBalancer()  {}
40   
41 private:
42   void init();
43 public:
44   inline static MetaBalancer * Object() { return CkpvAccess(metalbInited)?(MetaBalancer *)CkLocalBranch(_metalb):NULL; }
45
46   static void initnodeFn(void);
47
48   void pup(PUP::er& p);
49
50   void ResumeClients();
51
52 /*  inline void SetLBPeriod(double s) { LDSetLBPeriod(myLDHandle, s);}
53   inline double GetLBPeriod() { return LDGetLBPeriod(myLDHandle);}*/ //NOTE
54
55   void ResetAdaptive();
56   int get_iteration();
57   bool AddLoad(int iteration, double load);
58   void ReceiveMinStats(CkReductionMsg *);
59   void TriggerSoon(int iteration_no, double imbalance_ratio, double tolerate_imb);
60   void LoadBalanceDecision(int, int);
61   void LoadBalanceDecisionFinal(int, int);
62   void ReceiveIterationNo(int, int); // Receives the current iter no
63   void HandleAdaptiveNoObj();
64   void RegisterNoObjCallback(int index);
65   void TriggerAdaptiveReduction();
66
67   bool generatePlan(int& period, double& ratio_at_t);
68   bool getLineEq(double new_load_percent, double& aslope, double& ac, double& mslope, double& mc);
69   bool getPeriodForLinear(double a, double b, double c, int& period);
70   bool getPeriodForStrategy(double new_load, double overhead_percent, 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   int mystep;
92   std::vector<double> total_load_vec;
93   // Keeps track of how many local chares contributed
94   std::vector<int> total_count_vec;
95   std::vector<int> lbdb_no_obj_callback;
96   int max_iteration;
97
98   double after_lb_max;
99   double after_lb_avg;
100   double prev_idle;
101   double alpha_beta_cost_to_load;
102   int is_prev_lb_refine;
103
104   struct AdaptiveData {
105     double iteration;
106     double max_load;
107     double avg_load;
108     double utilization;
109     double idle_time;
110   };
111
112   struct AdaptiveMetaBalancer {
113     std::vector<AdaptiveData> history_data;
114     int lb_iter_no;
115   } adaptive_lbdb;
116
117   struct AdaptiveLBInfo {
118     AdaptiveLBInfo() {
119       max_avg_ratio = 1;
120       remote_local_ratio = 1;
121     }
122     double max_avg_ratio;
123     double remote_local_ratio;
124   };
125
126   // TODO: Separate out the datastructure required by just the central and on all
127   // processors
128   struct AdaptiveLBStructure {
129     int tentative_period;
130     int final_lb_period;
131     // This is based on the linear extrapolation
132     int lb_calculated_period;
133     int lb_iteration_no;
134     // This is set when all the processor sends the maximum iteration no
135     int global_max_iter_no;
136     // This keeps track of what was the max iteration no we had previously
137     // received. TODO: Mostly global_max_iter_no should be sufficied.
138     int tentative_max_iter_no;
139     // TODO: Use reduction to collect max iteration. Then we don't need this
140     // counter.
141     int global_recv_iter_counter;
142     // true indicates it is in Inform->ReceiveMaxIter->FinalLBPeriod stage.
143     bool in_progress;
144     double lb_strategy_cost;
145     double lb_migration_cost;
146     bool doCommStrategy;
147     int lb_msg_send_no;
148     int lb_msg_recv_no;
149     // Total AtSync calls from all the chares residing on the processor
150     int total_syncs_called;
151     int last_lb_type;
152     AdaptiveLBInfo greedy_info;
153     AdaptiveLBInfo refine_info;
154     AdaptiveLBInfo comm_info;
155     AdaptiveLBInfo comm_refine_info;
156   } adaptive_struct;
157
158 public:
159   bool lb_in_progress;
160
161 public:
162 };
163
164 inline MetaBalancer* MetaBalancerObj() { return MetaBalancer::Object(); }
165
166 #endif /* LDATABASE_H */
167
168 /*@}*/