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
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
97   int max_iteration;
98
99   double after_lb_max;
100   double after_lb_avg;
101   double prev_idle;
102   double alpha_beta_cost_to_load;
103   int is_prev_lb_refine;
104
105   struct AdaptiveData {
106     double iteration;
107     double max_load;
108     double avg_load;
109     double utilization;
110     double idle_time;
111   };
112
113   struct AdaptiveMetaBalancer {
114     CkVec<AdaptiveData> history_data;
115     int lb_iter_no;
116   } adaptive_lbdb;
117
118   struct AdaptiveLBInfo {
119     AdaptiveLBInfo() {
120       max_avg_ratio = 1;
121       remote_local_ratio = 1;
122     }
123     double max_avg_ratio;
124     double remote_local_ratio;
125   };
126
127   // TODO: Separate out the datastructure required by just the central and on all
128   // processors
129   struct AdaptiveLBStructure {
130     int tentative_period;
131     int final_lb_period;
132     // This is based on the linear extrapolation
133     int lb_calculated_period;
134     int lb_iteration_no;
135     // This is set when all the processor sends the maximum iteration no
136     int global_max_iter_no;
137     // This keeps track of what was the max iteration no we had previously
138     // received. TODO: Mostly global_max_iter_no should be sufficied.
139     int tentative_max_iter_no;
140     // TODO: Use reduction to collect max iteration. Then we don't need this
141     // counter.
142     int global_recv_iter_counter;
143     // true indicates it is in Inform->ReceiveMaxIter->FinalLBPeriod stage.
144     bool in_progress;
145     double lb_strategy_cost;
146     double lb_migration_cost;
147     bool doCommStrategy;
148     int lb_msg_send_no;
149     int lb_msg_recv_no;
150     // Total AtSync calls from all the chares residing on the processor
151     int total_syncs_called;
152     int last_lb_type;
153     AdaptiveLBInfo greedy_info;
154     AdaptiveLBInfo refine_info;
155     AdaptiveLBInfo comm_info;
156     AdaptiveLBInfo comm_refine_info;
157   } adaptive_struct;
158
159 public:
160   bool lb_in_progress;
161
162 public:
163 };
164
165 inline MetaBalancer* MetaBalancerObj() { return MetaBalancer::Object(); }
166
167 #endif /* LDATABASE_H */
168
169 /*@}*/