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
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   static void periodicCall(void *ad);
64   static void checkForNoObj(void *ad);
65   void HandleAdaptiveNoObj();
66   void RegisterNoObjCallback(int index);
67   void TriggerAdaptiveReduction();
68
69   bool generatePlan(int& period, double& ratio_at_t);
70   bool getLineEq(double new_load_percent, double& aslope, double& ac, double& mslope, double& mc);
71   bool getPeriodForLinear(double a, double b, double c, int& period);
72   bool getPeriodForStrategy(double new_load, double overhead_percent, int& period, double& ratio_at_t);
73   int getPredictedLBPeriod(bool& is_tentative);
74
75   bool isStrategyComm();
76
77   void UpdateAfterLBData(int is_lb_refine, double lb_max, double lb_avg, double
78       local_comm, double remote_comm);
79
80   void UpdateAfterLBData(double max_load, double max_cpu, double avg_load);
81   void UpdateAfterLBComm(double alpha_beta_cost);
82   void GetPrevLBData(int& lb_type, double& lb_max_avg_ratio, double&
83       local_remote_comm_ratio);
84   void GetLBDataForLB(int lb_type, double& lb_max_avg_ratio, double&
85       local_remote_comm_ratio);
86
87   void SetMigrationCost(double lb_migration_cost);
88   void SetStrategyCost(double lb_strategy_cost);
89
90 private:
91   //CProxy_MetaBalancer thisProxy;
92   LBDatabase* lbdatabase;
93   int mystep;
94   std::vector<double> total_load_vec;
95   // Keeps track of how many local chares contributed
96   std::vector<int> total_count_vec;
97   std::vector<int> lbdb_no_obj_callback;
98
99   int max_iteration;
100
101   double after_lb_max;
102   double after_lb_avg;
103   double prev_idle;
104   double alpha_beta_cost_to_load;
105   int is_prev_lb_refine;
106
107   struct AdaptiveData {
108     double iteration;
109     double max_load;
110     double avg_load;
111     double utilization;
112     double idle_time;
113   };
114
115   struct AdaptiveMetaBalancer {
116     CkVec<AdaptiveData> history_data;
117     int lb_iter_no;
118   } adaptive_lbdb;
119
120   struct AdaptiveLBInfo {
121     AdaptiveLBInfo() {
122       max_avg_ratio = 1;
123       remote_local_ratio = 1;
124     }
125     double max_avg_ratio;
126     double remote_local_ratio;
127   };
128
129   // TODO: Separate out the datastructure required by just the central and on all
130   // processors
131   struct AdaptiveLBStructure {
132     int tentative_period;
133     int final_lb_period;
134     // This is based on the linear extrapolation
135     int lb_calculated_period;
136     int lb_iteration_no;
137     // This is set when all the processor sends the maximum iteration no
138     int global_max_iter_no;
139     // This keeps track of what was the max iteration no we had previously
140     // received. TODO: Mostly global_max_iter_no should be sufficied.
141     int tentative_max_iter_no;
142     // TODO: Use reduction to collect max iteration. Then we don't need this
143     // counter.
144     int global_recv_iter_counter;
145     // true indicates it is in Inform->ReceiveMaxIter->FinalLBPeriod stage.
146     bool in_progress;
147     double lb_strategy_cost;
148     double lb_migration_cost;
149     bool doCommStrategy;
150     int lb_msg_send_no;
151     int lb_msg_recv_no;
152     // Total AtSync calls from all the chares residing on the processor
153     int total_syncs_called;
154     int last_lb_type;
155     AdaptiveLBInfo greedy_info;
156     AdaptiveLBInfo refine_info;
157     AdaptiveLBInfo comm_info;
158     AdaptiveLBInfo comm_refine_info;
159   } adaptive_struct;
160
161 public:
162   bool lb_in_progress;
163
164 public:
165 };
166
167 inline MetaBalancer* MetaBalancerObj() { return MetaBalancer::Object(); }
168
169 #endif /* LDATABASE_H */
170
171 /*@}*/