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