Forgot to check this in with the header file. Switching GAMMA to GAMMA_MEM
[charm.git] / src / ck-com / AAPLearner.C
1 #include "AAPLearner.h"
2 #include "ComlibManager.h"
3 #include "EachToManyMulticastStrategy.h"
4
5 #define max(a,b) ((a > b) ? a : b)
6
7 AAPLearner::AAPLearner() {
8     init();
9 }
10
11 void AAPLearner::init() {
12     alpha = ALPHA;
13     beta = BETA;
14 }
15
16 Strategy *AAPLearner::optimizePattern(Strategy *strat, 
17                                            ComlibGlobalStats &stats) {
18     CharmStrategy *in_strat = (CharmStrategy *)strat;
19     double npes;              //, *pelist;
20     CharmStrategy *ostrat = NULL;
21
22     /*
23       if(in_strat->getType() == ARRAY_STRATEGY) {
24       in_strat->ainfo.getCombinedPeList(pelist, npes);
25       }
26       
27       if(in_strat->getType() == GROUP_STRATEGY) {
28       CkGroupID gid;
29       //Convert to combined pelist
30       in_strat->ginfo.getSourceGroup(gid, pelist, npes);
31       }
32     */
33
34     double degree = 0, msgsize = 0, nmsgs = 0;
35     stats.getAverageStats(strat->getInstance(), msgsize, nmsgs, degree, npes);
36
37     double dcost = computeDirect(npes, msgsize, degree);
38     double mcost = computeMesh(npes, msgsize, degree);
39     double gcost = computeGrid(npes, msgsize, degree);
40     double hcost = computeHypercube(npes, msgsize, degree);
41     double mincost = min4(dcost, mcost, gcost, hcost);
42
43     int minstrat = USE_MESH;
44     if(dcost == mincost) 
45         minstrat = USE_DIRECT;
46     else if(mcost == mincost)                     
47         minstrat = USE_MESH;                
48     else if(gcost == mincost) 
49         minstrat = USE_GRID;
50     else if(hcost == mincost) 
51         minstrat = USE_HYPERCUBE;
52
53     CkPrintf("Choosing router %d, %g, %g, %g, %g; %g : %g,%g,%g\n", minstrat, 
54              mcost, hcost, gcost, dcost, mincost, npes, msgsize, degree);
55     
56     if(in_strat->getType() == ARRAY_STRATEGY) {
57         CkArrayID said, daid;
58         CkArrayIndexMax *sidxlist, *didxlist;
59         int nsrc, ndest;
60         
61         in_strat->ainfo.getSourceArray(said, sidxlist, nsrc);
62         in_strat->ainfo.getDestinationArray(daid, didxlist, ndest);
63                 
64         ostrat = new EachToManyMulticastStrategy
65              (minstrat, said, daid,
66              nsrc, sidxlist, ndest,
67              didxlist);
68
69         ostrat->setInstance(in_strat->getInstance());
70     }
71     
72     //Group strategy implement later, foo bar !!
73     if(in_strat->getType() == GROUP_STRATEGY) {
74         CkGroupID gid;
75         int src_npes, *src_pelist;
76         int dest_npes, *dest_pelist;
77         in_strat->ginfo.getSourceGroup(gid, src_pelist, src_npes);
78         in_strat->ginfo.getDestinationGroup(gid, dest_pelist, dest_npes); 
79
80         ostrat = new EachToManyMulticastStrategy
81             (minstrat, src_npes, src_pelist, dest_npes, dest_pelist);
82     }
83
84     return ostrat;
85 }
86
87 //P = number of processors, m = msgsize, d = degree
88 double AAPLearner::computeDirect(double P, double m, double d) {
89     double cost1, cost2;
90
91     /*  //Old equations do not model bursts 
92       cost = d * alpha;
93       cost += d * m * beta;
94     */
95
96     cost1 = (d-1) * ALPHA_NIC1 + alpha + m * beta + d * m * GAMMA_NIC; 
97     cost2 = alpha + d * ALPHA_NIC2 +  d * m * beta + m * GAMMA_NIC;
98     
99     return max(cost1, cost2); 
100 }
101
102 //P = number of processors, m = msgsize, d = degree
103 double AAPLearner::computeMesh(double P, double m, double d) {
104
105     double cost1, cost2;
106
107     /* old equation 
108     cost = 2 * sqrt((double) P) * alpha;
109     cost += 2 * d * m * beta;
110     */
111
112     double sqrt_p = ceil(sqrt((double) P));
113
114     cost1 = 2 * (sqrt_p - 2) * ALPHA_NIC1 + 2 * alpha + 2 * m * beta
115       + 2 * d * m * GAMMA_NIC; 
116     cost2 = 2 * alpha + 2 * (sqrt_p - 2) * ALPHA_NIC2 + 2 * d * m * beta + 2 * m *GAMMA_NIC;
117     
118     return max(cost1, cost2) + d * ALPHA_CHARM; 
119 }
120
121 //P = number of processors, m = msgsize, d = degree
122 double AAPLearner::computeHypercube(double P, double m, double d) {
123
124     //Temporarily disabling hypercube
125     return 100;
126
127     if(P == 0)
128         return 0;
129
130     double cost = 0.0;
131     double log_2_P = log(P)/log(2.0);
132     
133     if(d >= P/2) {
134       cost = log_2_P * alpha;
135       cost += (P/2) * log_2_P * m * (beta + GAMMA_NIC + GAMMA_MEM);
136     }
137     else {
138       cost = log_2_P * alpha;
139       cost += log_2_P * d * m * (beta + GAMMA_NIC + GAMMA_MEM);
140     }
141     
142     return cost + d * ALPHA_CHARM;
143 }
144
145 //P = number of processors, m = msgsize, d = degree
146 double AAPLearner::computeGrid(double P, double m, double d) {
147     double cost1, cost2 = 0.0;
148     /*
149       cost = 3 * cubeRoot((double) P) * alpha;
150       cost += 3 * d * m * beta;
151     */
152
153     double cbrt_p = ceil(cubeRoot((double) P));
154
155     cost1 = 3 * (cbrt_p - 2) * ALPHA_NIC1 + 3 * alpha + 3 * m * beta +
156       3 * d *m * GAMMA_NIC;  
157     cost2 = 3 * alpha + 3 * (cbrt_p - 2) * ALPHA_NIC2 + 3 * d * m * beta + 3 * m *GAMMA_NIC; 
158     
159     return max(cost1, cost2) + d * ALPHA_CHARM;
160 }
161