Making the learner a dynamic switch rather than a compile time switch.
[charm.git] / src / ck-com / AAMLearner.C
1 #include "AAMLearner.h"
2 #include "ComlibManager.h"
3
4 #include "EachToManyMulticastStrategy.h"
5 //#include "RingMulticastStrategy.h"
6
7 AAMLearner::AAMLearner() {
8    init();
9 }
10
11 void AAMLearner::init() {
12     alpha = ALPHA;
13     beta = BETA;
14     gamma = GAMMA;
15 }
16
17 Strategy *AAMLearner::optimizePattern(Strategy *strat, 
18                                            ComlibGlobalStats &stats) {
19     CharmStrategy *in_strat = (CharmStrategy *)strat;
20     double npes;              //, *pelist;
21     CharmStrategy *ostrat = NULL;
22
23     double degree = 0, msgsize = 0, nmsgs = 0;
24     stats.getAverageStats(strat->getInstance(), msgsize, nmsgs, 
25                           degree, npes);
26
27     double dcost = computeDirect(npes, msgsize, degree);
28     double mcost = computeMesh(npes, msgsize, degree);
29     double gcost = computeGrid(npes, msgsize, degree);
30     double hcost = computeHypercube(npes, msgsize, degree);
31     double mincost = min4(dcost, mcost, gcost, hcost);
32
33     int minstrat = -1;
34     if(in_strat->getType() == ARRAY_STRATEGY) {
35         CkArrayID said, daid;
36         CkArrayIndexMax *sidxlist, *didxlist;
37         int nsrc, ndest;
38         
39         in_strat->ainfo.getSourceArray(said, sidxlist, nsrc);
40         in_strat->ainfo.getDestinationArray(daid, didxlist, ndest);
41                
42         if(dcost == mincost) 
43             minstrat = USE_DIRECT;        
44         
45         else if(mcost == mincost) 
46             minstrat = USE_MESH;                
47         else if(gcost == mincost) 
48             minstrat = USE_GRID;
49         else if(hcost == mincost) 
50             minstrat = USE_HYPERCUBE;               
51
52         //CkPrintf("Choosing router %d, %g, %g, %g\n", minstrat, 
53         //       mcost, hcost, dcost);
54         
55         //if(minstrat != USE_DIRECT) {
56         ostrat = new EachToManyMulticastStrategy
57             (minstrat, said, daid,
58              nsrc, sidxlist, ndest,
59              didxlist);
60         
61         ostrat->setMulticast();
62
63         /*
64           }        
65           else {
66           ostrat = new RingMulticastStrategy(said, daid);
67           
68           }
69         */
70         
71         ostrat->setInstance(in_strat->getInstance());
72         ((EachToManyMulticastStrategy *)ostrat)->enableLearning();
73     }
74     else
75         CkAbort("Groups Not Implemented Yet\n");
76
77     //Group strategy implement later, foo bar !!
78     
79     return ostrat;
80 }
81
82 //P = number of processors, m = msgsize, d = degree
83 double AAMLearner::computeDirect(double P, double m, double d) {
84     double cost = 0.0;
85     cost = d * alpha;
86     cost += d * m * beta;
87     
88     return cost;
89 }
90
91 /******************* CHECK EQUATIONS FOR AAM ***********/
92 //P = number of processors, m = msgsize, d = degree
93 double AAMLearner::computeMesh(double P, double m, double d) {
94     double cost = 0.0;
95     cost = 2 * sqrt((double) P) * alpha;
96     cost += d * m * (beta + gamma);
97     
98     return cost;
99 }
100
101 //P = number of processors, m = msgsize, d = degree
102 double AAMLearner::computeHypercube(double P, double m, double d) {
103
104     if(P == 0)
105         return 0;
106
107     double cost = 0.0;
108     double log_2_P = log(P)/log(2.0);
109     
110     cost = log_2_P * alpha;
111     cost += d * m * (beta + gamma);
112
113     return cost;
114 }
115
116 //P = number of processors, m = msgsize, d = degree
117 double AAMLearner::computeGrid(double P, double m, double d) {
118
119     double cost = 0.0;
120     cost = 3 * cubeRoot((double) P) * alpha;
121     cost += d * m * (beta + gamma);
122     
123     return cost;
124 }
125