00001 // #ifdef filippo 00002 00003 // #include "AAPLearner.h" 00004 // #include "ComlibManager.h" 00005 // #include "EachToManyMulticastStrategy.h" 00006 00007 // #define max(a,b) ((a > b) ? a : b) 00008 00009 // AAPLearner::AAPLearner() { 00010 // init(); 00011 // } 00012 00013 // void AAPLearner::init() { 00014 // alpha = ALPHA; 00015 // beta = BETA; 00016 // } 00017 00018 // Strategy *AAPLearner::optimizePattern(Strategy *strat, 00019 // ComlibGlobalStats &stats) { 00020 // CharmStrategy *in_strat = (CharmStrategy *)strat; 00021 // double npes; //, *pelist; 00022 // CharmStrategy *ostrat = NULL; 00023 00024 // /* 00025 // if(in_strat->getType() == ARRAY_STRATEGY) { 00026 // in_strat->ainfo.getCombinedPeList(pelist, npes); 00027 // } 00028 00029 // if(in_strat->getType() == GROUP_STRATEGY) { 00030 // CkGroupID gid; 00031 // //Convert to combined pelist 00032 // in_strat->ginfo.getSourceGroup(gid, pelist, npes); 00033 // } 00034 // */ 00035 00036 // double degree = 0, msgsize = 0, nmsgs = 0; 00037 // stats.getAverageStats(strat->getInstance(), msgsize, nmsgs, degree, npes); 00038 00039 // double dcost = computeDirect(npes, msgsize, degree); 00040 // double mcost = computeMesh(npes, msgsize, degree); 00041 // double gcost = computeGrid(npes, msgsize, degree); 00042 // double hcost = computeHypercube(npes, msgsize, degree); 00043 // double mincost = min4(dcost, mcost, gcost, hcost); 00044 00045 // int minstrat = USE_MESH; 00046 // if(dcost == mincost) 00047 // minstrat = USE_DIRECT; 00048 // else if(mcost == mincost) 00049 // minstrat = USE_MESH; 00050 // else if(gcost == mincost) 00051 // minstrat = USE_GRID; 00052 // else if(hcost == mincost) 00053 // minstrat = USE_HYPERCUBE; 00054 00055 // //CkPrintf("Choosing router %d, %g, %g, %g, %g; %g : %g,%g,%g\n", minstrat, 00056 // // mcost, hcost, gcost, dcost, mincost, npes, msgsize, degree); 00057 00058 // if(in_strat->getType() == ARRAY_STRATEGY) { 00059 // CkArrayID said, daid; 00060 // CkArrayIndex *sidxlist, *didxlist; 00061 // int nsrc, ndest; 00062 00063 // in_strat->ainfo.getSourceArray(said, sidxlist, nsrc); 00064 // in_strat->ainfo.getDestinationArray(daid, didxlist, ndest); 00065 00066 // ostrat = new EachToManyMulticastStrategy 00067 // (minstrat, said, daid, 00068 // nsrc, sidxlist, ndest, 00069 // didxlist); 00070 00071 // ostrat->setInstance(in_strat->getInstance()); 00072 // ((EachToManyMulticastStrategy *) ostrat)->enableLearning(); 00073 // } 00074 00075 // //Group strategy implement later, foo bar !! 00076 // if(in_strat->getType() == GROUP_STRATEGY) { 00077 // CkGroupID gid; 00078 // int src_npes, *src_pelist; 00079 // int dest_npes, *dest_pelist; 00080 // in_strat->ginfo.getSourceGroup(gid, src_pelist, src_npes); 00081 // in_strat->ginfo.getDestinationGroup(gid, dest_pelist, dest_npes); 00082 00083 // ostrat = new EachToManyMulticastStrategy 00084 // (minstrat, src_npes, src_pelist, dest_npes, dest_pelist); 00085 // ((EachToManyMulticastStrategy *) ostrat)->enableLearning(); 00086 // ostrat->setInstance(in_strat->getInstance()); 00087 // } 00088 00089 // return ostrat; 00090 // } 00091 00092 // //P = number of processors, m = msgsize, d = degree 00093 // double AAPLearner::computeDirect(double P, double m, double d) { 00094 // double cost1, cost2; 00095 00096 // /* //Old equations do not model bursts 00097 // cost = d * alpha; 00098 // cost += d * m * beta; 00099 // */ 00100 00101 // cost1 = (d-1) * ALPHA_NIC1 + alpha + m * beta + d * m * GAMMA_NIC; 00102 // cost2 = alpha + d * ALPHA_NIC2 + d * m * beta + m * GAMMA_NIC; 00103 00104 // return max(cost1, cost2); 00105 // } 00106 00107 // //P = number of processors, m = msgsize, d = degree 00108 // double AAPLearner::computeMesh(double P, double m, double d) { 00109 00110 // double cost1, cost2; 00111 00112 // /* old equation 00113 // cost = 2 * sqrt((double) P) * alpha; 00114 // cost += 2 * d * m * beta; 00115 // */ 00116 00117 // double sqrt_p = ceil(sqrt((double) P)); 00118 00119 // cost1 = 2 * (sqrt_p - 2) * ALPHA_NIC1 + 2 * alpha + 2 * m * beta 00120 // + 2 * d * m * GAMMA_NIC; 00121 // cost2 = 2 * alpha + 2 * (sqrt_p - 2) * ALPHA_NIC2 + 2 * d * m * beta + 2 * m *GAMMA_NIC; 00122 00123 // return max(cost1, cost2) + d * ALPHA_CHARM; 00124 // } 00125 00126 // //P = number of processors, m = msgsize, d = degree 00127 // double AAPLearner::computeHypercube(double P, double m, double d) { 00128 00129 // //Temporarily disabling hypercube 00130 // return 100; 00131 00132 // if(P == 0) 00133 // return 0; 00134 00135 // double cost = 0.0; 00136 // double log_2_P = log(P)/log(2.0); 00137 00138 // if(d >= P/2) { 00139 // cost = log_2_P * alpha; 00140 // cost += (P/2) * log_2_P * m * (beta + GAMMA_NIC + GAMMA_MEM); 00141 // } 00142 // else { 00143 // cost = log_2_P * alpha; 00144 // cost += log_2_P * d * m * (beta + GAMMA_NIC + GAMMA_MEM); 00145 // } 00146 00147 // return cost + d * ALPHA_CHARM; 00148 // } 00149 00150 // //P = number of processors, m = msgsize, d = degree 00151 // double AAPLearner::computeGrid(double P, double m, double d) { 00152 // double cost1, cost2 = 0.0; 00153 // /* 00154 // cost = 3 * cubeRoot((double) P) * alpha; 00155 // cost += 3 * d * m * beta; 00156 // */ 00157 00158 // double cbrt_p = ceil(cubeRoot((double) P)); 00159 00160 // cost1 = 3 * (cbrt_p - 2) * ALPHA_NIC1 + 3 * alpha + 3 * m * beta + 00161 // 3 * d *m * GAMMA_NIC; 00162 // cost2 = 3 * alpha + 3 * (cbrt_p - 2) * ALPHA_NIC2 + 3 * d * m * beta + 3 * m *GAMMA_NIC; 00163 00164 // return max(cost1, cost2) + d * ALPHA_CHARM; 00165 // } 00166 00167 // #endif
1.5.5