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