src/smpi/colls/smpi_mvapich2_selector_stampede.h

   1 /* selector for collective algorithms based on mvapich decision logic, with calibration from Stampede cluster at TACC*/
   2
   3 /* Copyright (c) 2009-2010, 2013-2014. The SimGrid Team.
   4  * All rights reserved.                                                     */
   5
   6 /* This is the tuning used by MVAPICH for Stampede platform based on (MV2_ARCH_INTEL_XEON_E5_2680_16, MV2_HCA_MLX_CX_FDR) */
   7
   8
   9
  10 /************ Alltoall variables and initializers                        */
  11
  12 #define MV2_MAX_NB_THRESHOLDS  32
  13 typedef struct {
  14   int min;
  15   int max;
  16   int (*MV2_pt_Alltoall_function) (void *sendbuf, int sendcount, MPI_Datatype sendtype,
  17       void *recvbuf, int recvcount, MPI_Datatype recvtype,
  18       MPI_Comm comm_ptr );
  19 } mv2_alltoall_tuning_element;
  20
  21 typedef struct {
  22   int numproc;
  23   int size_table;
  24   mv2_alltoall_tuning_element algo_table[MV2_MAX_NB_THRESHOLDS];
  25   mv2_alltoall_tuning_element in_place_algo_table[MV2_MAX_NB_THRESHOLDS];
  26 } mv2_alltoall_tuning_table;
  27
  28 int (*MV2_Alltoall_function) (void *sendbuf, int sendcount, MPI_Datatype sendtype, void *recvbuf, int recvcount, MPI_Datatype recvtype, MPI_Comm comm_ptr)=NULL;
  29
  30 /* Indicates number of processes per node */
  31 int *mv2_alltoall_table_ppn_conf = NULL;
  32 /* Indicates total number of configurations */
  33 int mv2_alltoall_num_ppn_conf = 1;
  34 int *mv2_size_alltoall_tuning_table = NULL;
  35 mv2_alltoall_tuning_table **mv2_alltoall_thresholds_table = NULL;
  36
  37
  38 #define MPIR_Alltoall_bruck_MV2 smpi_coll_tuned_alltoall_bruck
  39 #define MPIR_Alltoall_RD_MV2 smpi_coll_tuned_alltoall_rdb
  40 #define MPIR_Alltoall_Scatter_dest_MV2 smpi_coll_tuned_alltoall_ring
  41 #define MPIR_Alltoall_pairwise_MV2 smpi_coll_tuned_alltoall_pair
  42 #define MPIR_Alltoall_inplace_MV2 smpi_coll_tuned_alltoall_ring
  43
  44
  45 static void init_mv2_alltoall_tables_stampede(){
  46   int i;
  47   int agg_table_sum = 0;
  48   mv2_alltoall_tuning_table **table_ptrs = NULL;
  49   mv2_alltoall_num_ppn_conf = 3;
  50   mv2_alltoall_thresholds_table = xbt_malloc(sizeof(mv2_alltoall_tuning_table *)
  51       * mv2_alltoall_num_ppn_conf);
  52   table_ptrs = xbt_malloc(sizeof(mv2_alltoall_tuning_table *)
  53       * mv2_alltoall_num_ppn_conf);
  54   mv2_size_alltoall_tuning_table = xbt_malloc(sizeof(int) *
  55       mv2_alltoall_num_ppn_conf);
  56   mv2_alltoall_table_ppn_conf = xbt_malloc(mv2_alltoall_num_ppn_conf * sizeof(int));
  57   mv2_alltoall_table_ppn_conf[0] = 1;
  58   mv2_size_alltoall_tuning_table[0] = 6;
  59   mv2_alltoall_tuning_table mv2_tmp_alltoall_thresholds_table_1ppn[] = {
  60       {2,
  61           1,
  62           {{0, -1, &MPIR_Alltoall_pairwise_MV2},
  63           },
  64
  65           {{0, -1, &MPIR_Alltoall_inplace_MV2},
  66           },
  67       },
  68
  69       {4,
  70           2,
  71           {{0, 262144, &MPIR_Alltoall_Scatter_dest_MV2},
  72               {262144, -1, &MPIR_Alltoall_pairwise_MV2},
  73           },
  74
  75           {{0, -1, &MPIR_Alltoall_inplace_MV2},
  76           },
  77       },
  78
  79       {8,
  80           2,
  81           {{0, 8, &MPIR_Alltoall_RD_MV2},
  82               {8, -1, &MPIR_Alltoall_Scatter_dest_MV2},
  83           },
  84
  85           {{0, -1, &MPIR_Alltoall_inplace_MV2},
  86           },
  87       },
  88
  89       {16,
  90           3,
  91           {{0, 64, &MPIR_Alltoall_RD_MV2},
  92               {64, 512, &MPIR_Alltoall_bruck_MV2},
  93               {512, -1, &MPIR_Alltoall_Scatter_dest_MV2},
  94           },
  95
  96           {{0,-1, &MPIR_Alltoall_inplace_MV2},
  97           },
  98       },
  99
 100       {32,
 101           3,
 102           {{0, 32, &MPIR_Alltoall_RD_MV2},
 103               {32, 2048, &MPIR_Alltoall_bruck_MV2},
 104               {2048, -1, &MPIR_Alltoall_Scatter_dest_MV2},
 105           },
 106
 107           {{0, -1, &MPIR_Alltoall_inplace_MV2},
 108           },
 109       },
 110
 111       {64,
 112           3,
 113           {{0, 8, &MPIR_Alltoall_RD_MV2},
 114               {8, 1024, &MPIR_Alltoall_bruck_MV2},
 115               {1024, -1, &MPIR_Alltoall_Scatter_dest_MV2},
 116           },
 117
 118           {{0, -1, &MPIR_Alltoall_inplace_MV2},
 119           },
 120       },
 121   };
 122   table_ptrs[0] = mv2_tmp_alltoall_thresholds_table_1ppn;
 123   mv2_alltoall_table_ppn_conf[1] = 2;
 124   mv2_size_alltoall_tuning_table[1] = 6;
 125   mv2_alltoall_tuning_table mv2_tmp_alltoall_thresholds_table_2ppn[] = {
 126       {4,
 127           2,
 128           {{0, 32, &MPIR_Alltoall_RD_MV2},
 129               {32, -1, &MPIR_Alltoall_Scatter_dest_MV2},
 130           },
 131
 132           {{0, -1, &MPIR_Alltoall_inplace_MV2},
 133           },
 134       },
 135
 136       {8,
 137           2,
 138           {{0, 64, &MPIR_Alltoall_RD_MV2},
 139               {64, -1, &MPIR_Alltoall_Scatter_dest_MV2},
 140           },
 141
 142           {{0, -1, &MPIR_Alltoall_inplace_MV2},
 143           },
 144       },
 145
 146       {16,
 147           3,
 148           {{0, 64, &MPIR_Alltoall_RD_MV2},
 149               {64, 2048, &MPIR_Alltoall_bruck_MV2},
 150               {2048, -1, &MPIR_Alltoall_Scatter_dest_MV2},
 151           },
 152
 153           {{0,-1, &MPIR_Alltoall_inplace_MV2},
 154           },
 155       },
 156
 157       {32,
 158           3,
 159           {{0, 16, &MPIR_Alltoall_RD_MV2},
 160               {16, 2048, &MPIR_Alltoall_bruck_MV2},
 161               {2048, -1, &MPIR_Alltoall_Scatter_dest_MV2},
 162           },
 163
 164           {{0, -1, &MPIR_Alltoall_inplace_MV2},
 165           },
 166       },
 167
 168       {64,
 169           3,
 170           {{0, 8, &MPIR_Alltoall_RD_MV2},
 171               {8, 1024, &MPIR_Alltoall_bruck_MV2},
 172               {1024, -1, &MPIR_Alltoall_Scatter_dest_MV2},
 173           },
 174
 175           {{0, -1, &MPIR_Alltoall_inplace_MV2},
 176           },
 177       },
 178
 179       {128,
 180           3,
 181           {{0, 4, &MPIR_Alltoall_RD_MV2},
 182               {4, 2048, &MPIR_Alltoall_bruck_MV2},
 183               {2048, -1, &MPIR_Alltoall_Scatter_dest_MV2},
 184           },
 185
 186           {{0, -1, &MPIR_Alltoall_inplace_MV2},
 187           },
 188       },
 189   };
 190   table_ptrs[1] = mv2_tmp_alltoall_thresholds_table_2ppn;
 191   mv2_alltoall_table_ppn_conf[2] = 16;
 192   mv2_size_alltoall_tuning_table[2] = 7;
 193   mv2_alltoall_tuning_table mv2_tmp_alltoall_thresholds_table_16ppn[] = {
 194       {16,
 195           2,
 196           {{0, 2048, &MPIR_Alltoall_bruck_MV2},
 197               {2048, -1,  &MPIR_Alltoall_Scatter_dest_MV2},
 198           },
 199
 200           {{32768, -1, &MPIR_Alltoall_inplace_MV2},
 201           },
 202       },
 203
 204       {32,
 205           2,
 206           {{0, 2048, &MPIR_Alltoall_bruck_MV2},
 207               {2048, -1, &MPIR_Alltoall_Scatter_dest_MV2},
 208           },
 209
 210           {{16384, -1, &MPIR_Alltoall_inplace_MV2},
 211           },
 212       },
 213
 214       {64,
 215           3,
 216           {{0, 2048, &MPIR_Alltoall_bruck_MV2},
 217               {2048, 16384, &MPIR_Alltoall_Scatter_dest_MV2},
 218               {16384, -1, &MPIR_Alltoall_pairwise_MV2},
 219           },
 220
 221           {{32768, 131072, &MPIR_Alltoall_inplace_MV2},
 222           },
 223       },
 224
 225       {128,
 226           2,
 227           {{0, 2048, &MPIR_Alltoall_bruck_MV2},
 228               {2048, -1, &MPIR_Alltoall_pairwise_MV2},
 229           },
 230
 231           {{16384,65536, &MPIR_Alltoall_inplace_MV2},
 232           },
 233       },
 234
 235       {256,
 236           2,
 237           {{0, 1024, &MPIR_Alltoall_bruck_MV2},
 238               {1024, -1, &MPIR_Alltoall_pairwise_MV2},
 239           },
 240
 241           {{16384, 65536, &MPIR_Alltoall_inplace_MV2},
 242           },
 243       },
 244
 245       {512,
 246           2,
 247           {{0, 1024, &MPIR_Alltoall_bruck_MV2},
 248               {1024, -1, &MPIR_Alltoall_pairwise_MV2},
 249           },
 250
 251           {{16384, 65536, &MPIR_Alltoall_inplace_MV2},
 252           },
 253       },
 254       {1024,
 255           2,
 256           {{0, 1024, &MPIR_Alltoall_bruck_MV2},
 257               {1024, -1, &MPIR_Alltoall_pairwise_MV2},
 258           },
 259
 260           {{16384, 65536, &MPIR_Alltoall_inplace_MV2},
 261           },
 262       },
 263
 264   };
 265   table_ptrs[2] = mv2_tmp_alltoall_thresholds_table_16ppn;
 266   agg_table_sum = 0;
 267   for (i = 0; i < mv2_alltoall_num_ppn_conf; i++) {
 268       agg_table_sum += mv2_size_alltoall_tuning_table[i];
 269   }
 270   mv2_alltoall_thresholds_table[0] =
 271       xbt_malloc(agg_table_sum * sizeof (mv2_alltoall_tuning_table));
 272   memcpy(mv2_alltoall_thresholds_table[0], table_ptrs[0],
 273       (sizeof(mv2_alltoall_tuning_table)
 274           * mv2_size_alltoall_tuning_table[0]));
 275   for (i = 1; i < mv2_alltoall_num_ppn_conf; i++) {
 276       mv2_alltoall_thresholds_table[i] =
 277           mv2_alltoall_thresholds_table[i - 1]
 278                                         + mv2_size_alltoall_tuning_table[i - 1];
 279       memcpy(mv2_alltoall_thresholds_table[i], table_ptrs[i],
 280           (sizeof(mv2_alltoall_tuning_table)
 281               * mv2_size_alltoall_tuning_table[i]));
 282   }
 283   xbt_free(table_ptrs);
 284
 285
 286 }
 287
 288
 289 /************ Allgather variables and initializers                        */
 290
 291 typedef struct {
 292   int min;
 293   int max;
 294   int (*MV2_pt_Allgather_function)(void *sendbuf,
 295       int sendcount,
 296       MPI_Datatype sendtype,
 297       void *recvbuf,
 298       int recvcount,
 299       MPI_Datatype recvtype, MPI_Comm comm_ptr);
 300 } mv2_allgather_tuning_element;
 301
 302 typedef struct {
 303   int numproc;
 304   int two_level[MV2_MAX_NB_THRESHOLDS];
 305   int size_inter_table;
 306   mv2_allgather_tuning_element inter_leader[MV2_MAX_NB_THRESHOLDS];
 307 } mv2_allgather_tuning_table;
 308
 309 int (*MV2_Allgather_function)(void *sendbuf,
 310     int sendcount,
 311     MPI_Datatype sendtype,
 312     void *recvbuf,
 313     int recvcount,
 314     MPI_Datatype recvtype, MPI_Comm comm);
 315
 316 int *mv2_allgather_table_ppn_conf = NULL;
 317 int mv2_allgather_num_ppn_conf = 1;
 318 int *mv2_size_allgather_tuning_table = NULL;
 319 mv2_allgather_tuning_table **mv2_allgather_thresholds_table = NULL;
 320
 321 #define MPIR_Allgather_Bruck_MV2 smpi_coll_tuned_allgather_bruck
 322 #define MPIR_Allgather_RD_MV2 smpi_coll_tuned_allgather_rdb
 323 #define MPIR_Allgather_RD_Allgather_Comm_MV2 smpi_coll_tuned_allgather_rdb
 324 #define MPIR_Allgather_Ring_MV2 smpi_coll_tuned_allgather_ring
 325
 326
 327 static void init_mv2_allgather_tables_stampede(){
 328   int i;
 329   int agg_table_sum = 0;
 330   mv2_allgather_tuning_table **table_ptrs = NULL;
 331   mv2_allgather_num_ppn_conf = 3;
 332   mv2_allgather_thresholds_table
 333   = xbt_malloc(sizeof(mv2_allgather_tuning_table *)
 334       * mv2_allgather_num_ppn_conf);
 335   table_ptrs = xbt_malloc(sizeof(mv2_allgather_tuning_table *)
 336       * mv2_allgather_num_ppn_conf);
 337   mv2_size_allgather_tuning_table = xbt_malloc(sizeof(int) *
 338       mv2_allgather_num_ppn_conf);
 339   mv2_allgather_table_ppn_conf
 340   = xbt_malloc(mv2_allgather_num_ppn_conf * sizeof(int));
 341   mv2_allgather_table_ppn_conf[0] = 1;
 342   mv2_size_allgather_tuning_table[0] = 6;
 343   mv2_allgather_tuning_table mv2_tmp_allgather_thresholds_table_1ppn[] = {
 344       {
 345           2,
 346           {0},
 347           1,
 348           {
 349               {0, -1, &MPIR_Allgather_Ring_MV2},
 350           },
 351       },
 352       {
 353           4,
 354           {0,0},
 355           2,
 356           {
 357               {0, 262144, &MPIR_Allgather_RD_MV2},
 358               {262144, -1, &MPIR_Allgather_Ring_MV2},
 359           },
 360       },
 361       {
 362           8,
 363           {0,0},
 364           2,
 365           {
 366               {0, 131072, &MPIR_Allgather_RD_MV2},
 367               {131072, -1, &MPIR_Allgather_Ring_MV2},
 368           },
 369       },
 370       {
 371           16,
 372           {0,0},
 373           2,
 374           {
 375               {0, 131072, &MPIR_Allgather_RD_MV2},
 376               {131072, -1, &MPIR_Allgather_Ring_MV2},
 377           },
 378       },
 379       {
 380           32,
 381           {0,0},
 382           2,
 383           {
 384               {0, 65536, &MPIR_Allgather_RD_MV2},
 385               {65536, -1, &MPIR_Allgather_Ring_MV2},
 386           },
 387       },
 388       {
 389           64,
 390           {0,0},
 391           2,
 392           {
 393               {0, 32768, &MPIR_Allgather_RD_MV2},
 394               {32768, -1, &MPIR_Allgather_Ring_MV2},
 395           },
 396       },
 397   };
 398   table_ptrs[0] = mv2_tmp_allgather_thresholds_table_1ppn;
 399   mv2_allgather_table_ppn_conf[1] = 2;
 400   mv2_size_allgather_tuning_table[1] = 6;
 401   mv2_allgather_tuning_table mv2_tmp_allgather_thresholds_table_2ppn[] = {
 402       {
 403           4,
 404           {0,0},
 405           2,
 406           {
 407               {0, 524288, &MPIR_Allgather_RD_MV2},
 408               {524288, -1, &MPIR_Allgather_Ring_MV2},
 409           },
 410       },
 411       {
 412           8,
 413           {0,1,0},
 414           2,
 415           {
 416               {0, 32768, &MPIR_Allgather_RD_MV2},
 417               {32768, 524288, &MPIR_Allgather_Ring_MV2},
 418               {524288, -1, &MPIR_Allgather_Ring_MV2},
 419           },
 420       },
 421       {
 422           16,
 423           {0,1,0},
 424           2,
 425           {
 426               {0, 16384, &MPIR_Allgather_RD_MV2},
 427               {16384, 524288, &MPIR_Allgather_Ring_MV2},
 428               {524288, -1, &MPIR_Allgather_Ring_MV2},
 429           },
 430       },
 431       {
 432           32,
 433           {1,1,0},
 434           2,
 435           {
 436               {0, 65536, &MPIR_Allgather_RD_MV2},
 437               {65536, 524288, &MPIR_Allgather_Ring_MV2},
 438               {524288, -1, &MPIR_Allgather_Ring_MV2},
 439           },
 440       },
 441       {
 442           64,
 443           {1,1,0},
 444           2,
 445           {
 446               {0, 32768, &MPIR_Allgather_RD_MV2},
 447               {32768, 524288, &MPIR_Allgather_Ring_MV2},
 448               {524288, -1, &MPIR_Allgather_Ring_MV2},
 449           },
 450       },
 451       {
 452           128,
 453           {1,1,0},
 454           2,
 455           {
 456               {0, 65536, &MPIR_Allgather_RD_MV2},
 457               {65536, 524288, &MPIR_Allgather_Ring_MV2},
 458               {524288, -1, &MPIR_Allgather_Ring_MV2},
 459           },
 460       },
 461   };
 462   table_ptrs[1] = mv2_tmp_allgather_thresholds_table_2ppn;
 463   mv2_allgather_table_ppn_conf[2] = 16;
 464   mv2_size_allgather_tuning_table[2] = 6;
 465   mv2_allgather_tuning_table mv2_tmp_allgather_thresholds_table_16ppn[] = {
 466       {
 467           16,
 468           {0,0},
 469           2,
 470           {
 471               {0, 1024, &MPIR_Allgather_RD_MV2},
 472               {1024, -1, &MPIR_Allgather_Ring_MV2},
 473           },
 474       },
 475       {
 476           32,
 477           {0,0},
 478           2,
 479           {
 480               {0, 1024, &MPIR_Allgather_RD_Allgather_Comm_MV2},
 481               {1024, -1, &MPIR_Allgather_Ring_MV2},
 482           },
 483       },
 484       {
 485           64,
 486           {0,0},
 487           2,
 488           {
 489               {0, 1024, &MPIR_Allgather_RD_Allgather_Comm_MV2},
 490               {1024, -1, &MPIR_Allgather_Ring_MV2},
 491           },
 492       },
 493       {
 494           128,
 495           {0,0},
 496           2,
 497           {
 498               {0, 1024, &MPIR_Allgather_RD_Allgather_Comm_MV2},
 499               {1024, -1, &MPIR_Allgather_Ring_MV2},
 500           },
 501       },
 502       {
 503           256,
 504           {0,0},
 505           2,
 506           {
 507               {0, 1024, &MPIR_Allgather_RD_Allgather_Comm_MV2},
 508               {1024, -1, &MPIR_Allgather_Ring_MV2},
 509           },
 510       },
 511       {
 512           512,
 513           {0,0},
 514           2,
 515           {
 516               {0, 1024, &MPIR_Allgather_RD_Allgather_Comm_MV2},
 517               {1024, -1, &MPIR_Allgather_Ring_MV2},
 518           },
 519       },
 520
 521   };
 522   table_ptrs[2] = mv2_tmp_allgather_thresholds_table_16ppn;
 523   agg_table_sum = 0;
 524   for (i = 0; i < mv2_allgather_num_ppn_conf; i++) {
 525       agg_table_sum += mv2_size_allgather_tuning_table[i];
 526   }
 527   mv2_allgather_thresholds_table[0] =
 528       xbt_malloc(agg_table_sum * sizeof (mv2_allgather_tuning_table));
 529   memcpy(mv2_allgather_thresholds_table[0], table_ptrs[0],
 530       (sizeof(mv2_allgather_tuning_table)
 531           * mv2_size_allgather_tuning_table[0]));
 532   for (i = 1; i < mv2_allgather_num_ppn_conf; i++) {
 533       mv2_allgather_thresholds_table[i] =
 534           mv2_allgather_thresholds_table[i - 1]
 535                                          + mv2_size_allgather_tuning_table[i - 1];
 536       memcpy(mv2_allgather_thresholds_table[i], table_ptrs[i],
 537           (sizeof(mv2_allgather_tuning_table)
 538               * mv2_size_allgather_tuning_table[i]));
 539   }
 540   xbt_free(table_ptrs);
 541 }
 542
 543
 544 /************ Gather variables and initializers                        */
 545
 546 typedef struct {
 547   int min;
 548   int max;
 549   int (*MV2_pt_Gather_function)(void *sendbuf, int sendcnt,
 550       MPI_Datatype sendtype, void *recvbuf, int recvcnt,
 551       MPI_Datatype recvtype, int root, MPI_Comm  comm_ptr);
 552 } mv2_gather_tuning_element;
 553
 554
 555 typedef struct {
 556   int numproc;
 557   int size_inter_table;
 558   mv2_gather_tuning_element inter_leader[MV2_MAX_NB_THRESHOLDS];
 559   int size_intra_table;
 560   mv2_gather_tuning_element intra_node[MV2_MAX_NB_THRESHOLDS];
 561 } mv2_gather_tuning_table;
 562
 563 int mv2_size_gather_tuning_table=7;
 564 mv2_gather_tuning_table * mv2_gather_thresholds_table=NULL;
 565
 566 typedef int (*MV2_Gather_function_ptr) (void *sendbuf,
 567     int sendcnt,
 568     MPI_Datatype sendtype,
 569     void *recvbuf,
 570     int recvcnt,
 571     MPI_Datatype recvtype,
 572     int root, MPI_Comm comm);
 573
 574 MV2_Gather_function_ptr MV2_Gather_inter_leader_function = NULL;
 575 MV2_Gather_function_ptr MV2_Gather_intra_node_function = NULL;
 576
 577
 578 #define MPIR_Gather_MV2_Direct smpi_coll_tuned_gather_ompi_basic_linear
 579 #define MPIR_Gather_MV2_two_level_Direct smpi_coll_tuned_gather_ompi_basic_linear
 580 #define MPIR_Gather_intra smpi_coll_tuned_gather_mpich
 581
 582
 583 static void init_mv2_gather_tables_stampede(){
 584
 585   mv2_size_gather_tuning_table=7;
 586   mv2_gather_thresholds_table = xbt_malloc(mv2_size_gather_tuning_table*
 587       sizeof (mv2_gather_tuning_table));
 588   mv2_gather_tuning_table mv2_tmp_gather_thresholds_table[]={
 589       {16,
 590           2,{{0, 524288, &MPIR_Gather_MV2_Direct},
 591               {524288, -1, &MPIR_Gather_intra}},
 592               1,{{0, -1, &MPIR_Gather_MV2_Direct}}},
 593               {32,
 594                   3,{{0, 16384, &MPIR_Gather_MV2_Direct},
 595                       {16384, 131072, &MPIR_Gather_intra},
 596                       {131072, -1, &MPIR_Gather_MV2_two_level_Direct}},
 597                       1,{{0, -1, &MPIR_Gather_intra}}},
 598                       {64,
 599                           3,{{0, 256, &MPIR_Gather_MV2_two_level_Direct},
 600                               {256, 16384, &MPIR_Gather_MV2_Direct},
 601                               {256, -1, &MPIR_Gather_MV2_two_level_Direct}},
 602                               1,{{0, -1, &MPIR_Gather_intra}}},
 603                               {128,
 604                                   3,{{0, 512, &MPIR_Gather_MV2_two_level_Direct},
 605                                       {512, 16384, &MPIR_Gather_MV2_Direct},
 606                                       {16384, -1, &MPIR_Gather_MV2_two_level_Direct}},
 607                                       1,{{0, -1, &MPIR_Gather_intra}}},
 608                                       {256,
 609                                           3,{{0, 512, &MPIR_Gather_MV2_two_level_Direct},
 610                                               {512, 16384, &MPIR_Gather_MV2_Direct},
 611                                               {16384, -1, &MPIR_Gather_MV2_two_level_Direct}},
 612                                               1,{{0, -1, &MPIR_Gather_intra}}},
 613                                               {512,
 614                                                   3,{{0, 512, &MPIR_Gather_MV2_two_level_Direct},
 615                                                       {512, 16384, &MPIR_Gather_MV2_Direct},
 616                                                       {8196, -1, &MPIR_Gather_MV2_two_level_Direct}},
 617                                                       1,{{0, -1, &MPIR_Gather_intra}}},
 618                                                       {1024,
 619                                                           3,{{0, 512, &MPIR_Gather_MV2_two_level_Direct},
 620                                                               {512, 16384, &MPIR_Gather_MV2_Direct},
 621                                                               {8196, -1, &MPIR_Gather_MV2_two_level_Direct}},
 622                                                               1,{{0, -1, &MPIR_Gather_intra}}},
 623   };
 624
 625   memcpy(mv2_gather_thresholds_table, mv2_tmp_gather_thresholds_table,
 626       mv2_size_gather_tuning_table * sizeof (mv2_gather_tuning_table));
 627
 628 }
 629
 630
 631 /************ Allgatherv variables and initializers                        */
 632
 633 typedef struct {
 634   int min;
 635   int max;
 636   int (*MV2_pt_Allgatherv_function)(void *sendbuf,
 637       int sendcount,
 638       MPI_Datatype sendtype,
 639       void *recvbuf,
 640       int *recvcounts,
 641       int *displs,
 642       MPI_Datatype recvtype,
 643       MPI_Comm commg);
 644 } mv2_allgatherv_tuning_element;
 645
 646 typedef struct {
 647   int numproc;
 648   int size_inter_table;
 649   mv2_allgatherv_tuning_element inter_leader[MV2_MAX_NB_THRESHOLDS];
 650 } mv2_allgatherv_tuning_table;
 651
 652 int (*MV2_Allgatherv_function)(void *sendbuf,
 653     int sendcount,
 654     MPI_Datatype sendtype,
 655     void *recvbuf,
 656     int *recvcounts,
 657     int *displs,
 658     MPI_Datatype recvtype,
 659     MPI_Comm comm);
 660
 661 int mv2_size_allgatherv_tuning_table = 0;
 662 mv2_allgatherv_tuning_table *mv2_allgatherv_thresholds_table = NULL;
 663
 664 #define MPIR_Allgatherv_Rec_Doubling_MV2 smpi_coll_tuned_allgatherv_mpich_rdb
 665 #define MPIR_Allgatherv_Bruck_MV2 smpi_coll_tuned_allgatherv_ompi_bruck
 666 #define MPIR_Allgatherv_Ring_MV2 smpi_coll_tuned_allgatherv_mpich_ring
 667
 668
 669 static void init_mv2_allgatherv_tables_stampede(){
 670   mv2_size_allgatherv_tuning_table = 6;
 671   mv2_allgatherv_thresholds_table = xbt_malloc(mv2_size_allgatherv_tuning_table *
 672       sizeof (mv2_allgatherv_tuning_table));
 673   mv2_allgatherv_tuning_table mv2_tmp_allgatherv_thresholds_table[] = {
 674       {
 675           16,
 676           2,
 677           {
 678               {0, 512, &MPIR_Allgatherv_Rec_Doubling_MV2},
 679               {512, -1, &MPIR_Allgatherv_Ring_MV2},
 680           },
 681       },
 682       {
 683           32,
 684           2,
 685           {
 686               {0, 512, &MPIR_Allgatherv_Rec_Doubling_MV2},
 687               {512, -1, &MPIR_Allgatherv_Ring_MV2},
 688           },
 689       },
 690       {
 691           64,
 692           2,
 693           {
 694               {0, 256, &MPIR_Allgatherv_Rec_Doubling_MV2},
 695               {256, -1, &MPIR_Allgatherv_Ring_MV2},
 696           },
 697       },
 698       {
 699           128,
 700           2,
 701           {
 702               {0, 256, &MPIR_Allgatherv_Rec_Doubling_MV2},
 703               {256, -1, &MPIR_Allgatherv_Ring_MV2},
 704           },
 705       },
 706       {
 707           256,
 708           2,
 709           {
 710               {0, 256, &MPIR_Allgatherv_Rec_Doubling_MV2},
 711               {256, -1, &MPIR_Allgatherv_Ring_MV2},
 712           },
 713       },
 714       {
 715           512,
 716           2,
 717           {
 718               {0, 256, &MPIR_Allgatherv_Rec_Doubling_MV2},
 719               {256, -1, &MPIR_Allgatherv_Ring_MV2},
 720           },
 721       },
 722
 723   };
 724   memcpy(mv2_allgatherv_thresholds_table, mv2_tmp_allgatherv_thresholds_table,
 725       mv2_size_allgatherv_tuning_table * sizeof (mv2_allgatherv_tuning_table));
 726 }
 727
 728
 729 /************ Allreduce variables and initializers                        */
 730
 731 typedef struct {
 732   int min;
 733   int max;
 734   int (*MV2_pt_Allreduce_function)(void *sendbuf,
 735       void *recvbuf,
 736       int count,
 737       MPI_Datatype datatype,
 738       MPI_Op op, MPI_Comm comm);
 739 } mv2_allreduce_tuning_element;
 740
 741 typedef struct {
 742   int numproc;
 743   int mcast_enabled;
 744   int is_two_level_allreduce[MV2_MAX_NB_THRESHOLDS];
 745   int size_inter_table;
 746   mv2_allreduce_tuning_element inter_leader[MV2_MAX_NB_THRESHOLDS];
 747   int size_intra_table;
 748   mv2_allreduce_tuning_element intra_node[MV2_MAX_NB_THRESHOLDS];
 749 } mv2_allreduce_tuning_table;
 750
 751
 752 int (*MV2_Allreduce_function)(void *sendbuf,
 753     void *recvbuf,
 754     int count,
 755     MPI_Datatype datatype,
 756     MPI_Op op, MPI_Comm comm)=NULL;
 757
 758
 759 int (*MV2_Allreduce_intra_function)( void *sendbuf,
 760     void *recvbuf,
 761     int count,
 762     MPI_Datatype datatype,
 763     MPI_Op op, MPI_Comm comm)=NULL;
 764
 765 int mv2_size_allreduce_tuning_table = 0;
 766 mv2_allreduce_tuning_table *mv2_allreduce_thresholds_table = NULL;
 767
 768
 769
 770
 771
 772 static int MPIR_Allreduce_mcst_reduce_two_level_helper_MV2( void *sendbuf,
 773     void *recvbuf,
 774     int count,
 775     MPI_Datatype datatype,
 776     MPI_Op op, MPI_Comm comm)
 777 {
 778   return 0;
 779 }
 780
 781 static  int MPIR_Allreduce_mcst_reduce_redscat_gather_MV2( void *sendbuf,
 782     void *recvbuf,
 783     int count,
 784     MPI_Datatype datatype,
 785     MPI_Op op, MPI_Comm  comm)
 786 {
 787   return 0;
 788 }
 789
 790 static  int MPIR_Allreduce_reduce_p2p_MV2( void *sendbuf,
 791     void *recvbuf,
 792     int count,
 793     MPI_Datatype datatype,
 794     MPI_Op op, MPI_Comm  comm)
 795 {
 796   mpi_coll_reduce_fun(sendbuf,recvbuf,count,datatype,op,0,comm);
 797   return MPI_SUCCESS;
 798 }
 799
 800 static  int MPIR_Allreduce_reduce_shmem_MV2( void *sendbuf,
 801     void *recvbuf,
 802     int count,
 803     MPI_Datatype datatype,
 804     MPI_Op op, MPI_Comm  comm)
 805 {
 806   mpi_coll_reduce_fun(sendbuf,recvbuf,count,datatype,op,0,comm);
 807   return MPI_SUCCESS;
 808 }
 809
 810 #define MPIR_Allreduce_pt2pt_rd_MV2 smpi_coll_tuned_allreduce_rdb
 811 #define MPIR_Allreduce_pt2pt_rs_MV2 smpi_coll_tuned_allreduce_mvapich2_rs
 812
 813
 814
 815 static void init_mv2_allreduce_tables_stampede(){
 816   mv2_size_allreduce_tuning_table = 8;
 817   mv2_allreduce_thresholds_table = xbt_malloc(mv2_size_allreduce_tuning_table *
 818       sizeof (mv2_allreduce_tuning_table));
 819   mv2_allreduce_tuning_table mv2_tmp_allreduce_thresholds_table[] = {
 820       {
 821           16,
 822           0,
 823           {1, 0},
 824           2,
 825           {
 826               {0, 1024, &MPIR_Allreduce_pt2pt_rd_MV2},
 827               {1024, -1, &MPIR_Allreduce_pt2pt_rs_MV2},
 828           },
 829           2,
 830           {
 831               {0, 1024, &MPIR_Allreduce_reduce_shmem_MV2},
 832               {1024, -1, &MPIR_Allreduce_reduce_p2p_MV2},
 833           },
 834       },
 835       {
 836           32,
 837           0,
 838           {1, 1, 0},
 839           3,
 840           {
 841               {0, 1024, &MPIR_Allreduce_pt2pt_rd_MV2},
 842               {1024, 16384, &MPIR_Allreduce_pt2pt_rd_MV2},
 843               {16384, -1, &MPIR_Allreduce_pt2pt_rs_MV2},
 844           },
 845           2,
 846           {
 847               {0, 1024, &MPIR_Allreduce_reduce_shmem_MV2},
 848               {1024, 16384, &MPIR_Allreduce_reduce_p2p_MV2},
 849           },
 850       },
 851       {
 852           64,
 853           0,
 854           {1, 1, 0},
 855           3,
 856           {
 857               {0, 512, &MPIR_Allreduce_pt2pt_rd_MV2},
 858               {512, 16384, &MPIR_Allreduce_pt2pt_rd_MV2},
 859               {16384, -1, &MPIR_Allreduce_pt2pt_rs_MV2},
 860           },
 861           2,
 862           {
 863               {0, 512, &MPIR_Allreduce_reduce_shmem_MV2},
 864               {512, 16384, &MPIR_Allreduce_reduce_p2p_MV2},
 865           },
 866       },
 867       {
 868           128,
 869           0,
 870           {1, 1, 0},
 871           3,
 872           {
 873               {0, 512, &MPIR_Allreduce_pt2pt_rd_MV2},
 874               {512, 16384, &MPIR_Allreduce_pt2pt_rd_MV2},
 875               {16384, -1, &MPIR_Allreduce_pt2pt_rs_MV2},
 876           },
 877           2,
 878           {
 879               {0, 512, &MPIR_Allreduce_reduce_shmem_MV2},
 880               {512, 16384, &MPIR_Allreduce_reduce_p2p_MV2},
 881           },
 882       },
 883       {
 884           256,
 885           0,
 886           {1, 1, 0},
 887           3,
 888           {
 889               {0, 512, &MPIR_Allreduce_pt2pt_rd_MV2},
 890               {512, 16384, &MPIR_Allreduce_pt2pt_rd_MV2},
 891               {16384, -1, &MPIR_Allreduce_pt2pt_rs_MV2},
 892           },
 893           2,
 894           {
 895               {0, 512, &MPIR_Allreduce_reduce_shmem_MV2},
 896               {512, -1, &MPIR_Allreduce_reduce_p2p_MV2},
 897           },
 898       },
 899       {
 900           512,
 901           0,
 902           {1, 1, 0},
 903           3,
 904           {
 905               {0, 512, &MPIR_Allreduce_pt2pt_rd_MV2},
 906               {512, 16384, &MPIR_Allreduce_pt2pt_rd_MV2},
 907               {16384, -1, &MPIR_Allreduce_pt2pt_rs_MV2},
 908           },
 909           2,
 910           {
 911               {0, 512, &MPIR_Allreduce_reduce_shmem_MV2},
 912               {512, 16384, &MPIR_Allreduce_reduce_p2p_MV2},
 913           },
 914       },
 915       {
 916           1024,
 917           0,
 918           {1, 1, 1, 0},
 919           4,
 920           {
 921               {0, 512, &MPIR_Allreduce_pt2pt_rd_MV2},
 922               {512, 8192, &MPIR_Allreduce_pt2pt_rd_MV2},
 923               {8192, 65536, &MPIR_Allreduce_pt2pt_rs_MV2},
 924               {65536, -1, &MPIR_Allreduce_pt2pt_rs_MV2},
 925           },
 926           2,
 927           {
 928               {0, 512, &MPIR_Allreduce_reduce_shmem_MV2},
 929               {512, -1, &MPIR_Allreduce_reduce_p2p_MV2},
 930           },
 931       },
 932       {
 933           2048,
 934           0,
 935           {1, 1, 1, 0},
 936           4,
 937           {
 938               {0, 64, &MPIR_Allreduce_pt2pt_rd_MV2},
 939               {64, 512, &MPIR_Allreduce_reduce_p2p_MV2},
 940               {512, 4096, &MPIR_Allreduce_mcst_reduce_two_level_helper_MV2},
 941               {4096, 16384, &MPIR_Allreduce_pt2pt_rs_MV2},
 942               {16384, -1, &MPIR_Allreduce_pt2pt_rs_MV2},
 943           },
 944           2,
 945           {
 946               {0, 512, &MPIR_Allreduce_reduce_shmem_MV2},
 947               {512, -1, &MPIR_Allreduce_reduce_p2p_MV2},
 948           },
 949       },
 950
 951   };
 952   memcpy(mv2_allreduce_thresholds_table, mv2_tmp_allreduce_thresholds_table,
 953       mv2_size_allreduce_tuning_table * sizeof (mv2_allreduce_tuning_table));
 954 }
 955
 956
 957 /*
 958 Bcast deactivated for now, defaults to mpich one
 959 typedef struct {
 960     int min;
 961     int max;
 962     int (*MV2_pt_Bcast_function) (void *buf, int count, MPI_Datatype datatype,
 963                                   int root, MPI_Comm comm_ptr);
 964     int zcpy_pipelined_knomial_factor;
 965 } mv2_bcast_tuning_element;
 966
 967 typedef struct {
 968     int numproc;
 969     int bcast_segment_size;
 970     int intra_node_knomial_factor;
 971     int inter_node_knomial_factor;
 972     int is_two_level_bcast[MV2_MAX_NB_THRESHOLDS];
 973     int size_inter_table;
 974     mv2_bcast_tuning_element inter_leader[MV2_MAX_NB_THRESHOLDS];
 975     int size_intra_table;
 976     mv2_bcast_tuning_element intra_node[MV2_MAX_NB_THRESHOLDS];
 977 } mv2_bcast_tuning_table;
 978
 979 int mv2_size_bcast_tuning_table = 0;
 980 mv2_bcast_tuning_table *mv2_bcast_thresholds_table = NULL;
 981
 982
 983 int (*MV2_Bcast_function) (void *buffer, int count, MPI_Datatype datatype,
 984                            int root, MPI_Comm comm_ptr) = NULL;
 985
 986 int (*MV2_Bcast_intra_node_function) (void *buffer, int count, MPI_Datatype datatype,
 987                                       int root, MPI_Comm comm_ptr) = NULL;
 988
 989
 990  */
 991
 992
 993 /*
 994 static void init_mv2_bcast_tables_stampede(){
 995  //Stampede,
 996         mv2_size_bcast_tuning_table=8;
 997         mv2_bcast_thresholds_table = xbt_malloc(mv2_size_bcast_tuning_table *
 998                                                  sizeof (mv2_bcast_tuning_table));
 999
1000   mv2_bcast_tuning_table mv2_tmp_bcast_thresholds_table[]={
1001     {
1002             16,
1003             8192, 4, 4,
1004             {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
1005             11,
1006             {
1007               {0, 8, &MPIR_Pipelined_Bcast_Zcpy_MV2, 2},
1008               {8, 16, &MPIR_Pipelined_Bcast_Zcpy_MV2, 4},
1009               {16, 1024, &MPIR_Pipelined_Bcast_Zcpy_MV2, 2},
1010               {1024, 8192, &MPIR_Pipelined_Bcast_Zcpy_MV2, 4},
1011               {8192, 16384, &MPIR_Bcast_binomial_MV2, -1},
1012               {16384, 32768, &MPIR_Pipelined_Bcast_Zcpy_MV2, 4},
1013               {32768, 65536, &MPIR_Pipelined_Bcast_Zcpy_MV2, 2},
1014               {65536, 131072, &MPIR_Bcast_scatter_ring_allgather_shm_MV2, -1},
1015               {131072, 262144, &MPIR_Bcast_scatter_ring_allgather_MV2, -1},
1016               {262144, 524288, &MPIR_Bcast_scatter_doubling_allgather_MV2, -1},
1017               {524288, -1, &MPIR_Bcast_scatter_ring_allgather_MV2, -1}
1018             },
1019             11,
1020             {
1021               {0, 8, &MPIR_Shmem_Bcast_MV2, 2},
1022               {8, 16, &MPIR_Shmem_Bcast_MV2, 4},
1023               {16, 1024, &MPIR_Shmem_Bcast_MV2, 2},
1024               {1024, 8192, &MPIR_Shmem_Bcast_MV2, 4},
1025               {8192, 16384, &MPIR_Shmem_Bcast_MV2, -1},
1026               {16384, 32768, &MPIR_Shmem_Bcast_MV2, 4},
1027               {32768, 65536, &MPIR_Shmem_Bcast_MV2, 2},
1028               {65536, 131072, &MPIR_Shmem_Bcast_MV2, -1},
1029               {131072, 262144, &MPIR_Shmem_Bcast_MV2, -1},
1030               {262144, 524288, &MPIR_Shmem_Bcast_MV2, -1},
1031               {524288, -1, &MPIR_Shmem_Bcast_MV2, -1}
1032             }
1033     },
1034     {
1035             32,
1036             8192, 4, 4,
1037             {1, 1, 1, 1, 1, 1, 1, 1},
1038             8,
1039             {
1040               {0, 128, &MPIR_Pipelined_Bcast_Zcpy_MV2, 2},
1041               {128, 256, &MPIR_Pipelined_Bcast_Zcpy_MV2, 4},
1042               {256, 32768, &MPIR_Pipelined_Bcast_Zcpy_MV2, 2},
1043               {32768, 65536, &MPIR_Pipelined_Bcast_Zcpy_MV2, 4},
1044               {65536, 131072, &MPIR_Pipelined_Bcast_Zcpy_MV2, 2},
1045               {131072, 262144, &MPIR_Pipelined_Bcast_Zcpy_MV2, 8},
1046               {262144, 524288, &MPIR_Pipelined_Bcast_Zcpy_MV2, 2},
1047               {524288, -1, &MPIR_Pipelined_Bcast_Zcpy_MV2, 8}
1048             },
1049             8,
1050             {
1051               {0, 128, &MPIR_Shmem_Bcast_MV2, 2},
1052               {128, 256, &MPIR_Shmem_Bcast_MV2, 4},
1053               {256, 32768, &MPIR_Shmem_Bcast_MV2, 2},
1054               {32768, 65536, &MPIR_Shmem_Bcast_MV2, 4},
1055               {65536, 131072, &MPIR_Shmem_Bcast_MV2, 2},
1056               {131072, 262144, &MPIR_Shmem_Bcast_MV2, 8},
1057               {262144, 524288, &MPIR_Shmem_Bcast_MV2, 2},
1058               {524288, -1, &MPIR_Shmem_Bcast_MV2, 8}
1059             }
1060     },
1061     {
1062             64,
1063             8192, 4, 4,
1064             {1, 1, 1, 1, 1, 1, 1, 1, 1},
1065             9,
1066             {
1067               {0, 2, &MPIR_Pipelined_Bcast_Zcpy_MV2, 4},
1068               {2, 4, &MPIR_Pipelined_Bcast_Zcpy_MV2, 8},
1069               {4, 16, &MPIR_Pipelined_Bcast_Zcpy_MV2, 4},
1070               {16, 32, &MPIR_Pipelined_Bcast_Zcpy_MV2, 8},
1071               {32, 128, &MPIR_Pipelined_Bcast_Zcpy_MV2, 4},
1072               {128, 256, &MPIR_Pipelined_Bcast_Zcpy_MV2, 8},
1073               {256, 4096, &MPIR_Pipelined_Bcast_Zcpy_MV2, 4},
1074               {4096, 32768, &MPIR_Pipelined_Bcast_Zcpy_MV2, 8},
1075               {32768, -1, &MPIR_Pipelined_Bcast_Zcpy_MV2, 2}
1076             },
1077             9,
1078             {
1079               {0, 2, &MPIR_Shmem_Bcast_MV2, 4},
1080               {2, 4, &MPIR_Shmem_Bcast_MV2, 8},
1081               {4, 16, &MPIR_Shmem_Bcast_MV2, 4},
1082               {16, 32, &MPIR_Shmem_Bcast_MV2, 8},
1083               {32, 128, &MPIR_Shmem_Bcast_MV2, 4},
1084               {128, 256, &MPIR_Shmem_Bcast_MV2, 8},
1085               {256, 4096, &MPIR_Shmem_Bcast_MV2, 4},
1086               {4096, 32768, &MPIR_Shmem_Bcast_MV2, 8},
1087               {32768, -1, &MPIR_Shmem_Bcast_MV2, 2}
1088             }
1089     },
1090     {
1091             128,
1092             8192, 4, 4,
1093             {1, 1, 1, 0},
1094             4,
1095             {
1096               {0, 8192, &MPIR_Pipelined_Bcast_Zcpy_MV2, 8},
1097               {8192, 16384, &MPIR_Pipelined_Bcast_Zcpy_MV2, 4},
1098               {16384, 524288, &MPIR_Pipelined_Bcast_Zcpy_MV2, 2},
1099               {524288, -1, &MPIR_Bcast_scatter_ring_allgather_MV2, -1}
1100             },
1101             4,
1102             {
1103               {0, 8192, &MPIR_Shmem_Bcast_MV2, 8},
1104               {8192, 16384, &MPIR_Shmem_Bcast_MV2, 4},
1105               {16384, 524288, &MPIR_Shmem_Bcast_MV2, 2},
1106               {524288, -1, NULL, -1}
1107             }
1108     },
1109     {
1110             256,
1111             8192, 4, 4,
1112             {1, 1, 1, 1, 1},
1113             5,
1114             {
1115               {0, 16384, &MPIR_Pipelined_Bcast_Zcpy_MV2, 4},
1116               {16384, 131072, &MPIR_Pipelined_Bcast_Zcpy_MV2, 2},
1117               {131072, 262144, &MPIR_Bcast_scatter_ring_allgather_shm_MV2, -1},
1118               {262144, 524288, &MPIR_Pipelined_Bcast_Zcpy_MV2, 2},
1119               {524288, -1, &MPIR_Bcast_scatter_ring_allgather_shm_MV2, -1}
1120             },
1121             5,
1122             {
1123               {0, 16384, &MPIR_Shmem_Bcast_MV2, 4},
1124               {16384, 131072, &MPIR_Shmem_Bcast_MV2, 2},
1125               {131072, 262144, &MPIR_Shmem_Bcast_MV2, -1},
1126               {262144, 524288, &MPIR_Shmem_Bcast_MV2, 2},
1127               {524288, -1, &MPIR_Shmem_Bcast_MV2, -1}
1128             }
1129     },
1130     {
1131             512,
1132             8192, 4, 4,
1133             {1, 1, 1, 1, 1},
1134             5,
1135             {
1136               {0, 4096, &MPIR_Pipelined_Bcast_Zcpy_MV2, 8},
1137               {4096, 16384, &MPIR_Pipelined_Bcast_Zcpy_MV2, 4},
1138               {16384, 131072, &MPIR_Pipelined_Bcast_Zcpy_MV2, 2},
1139               {131072, 262144, &MPIR_Pipelined_Bcast_MV2, -1},
1140               {262144, -1, &MPIR_Bcast_scatter_ring_allgather_shm_MV2, -1}
1141             },
1142             5,
1143             {
1144               {0, 4096, &MPIR_Shmem_Bcast_MV2, 8},
1145               {4096, 16384, &MPIR_Shmem_Bcast_MV2, 4},
1146               {16384, 131072, &MPIR_Shmem_Bcast_MV2, 2},
1147               {131072, 262144, &MPIR_Shmem_Bcast_MV2, -1},
1148               {262144, -1, &MPIR_Shmem_Bcast_MV2, -1}
1149             }
1150     },
1151     {
1152             1024,
1153             8192, 4, 4,
1154             {1, 1, 1, 1, 1},
1155             5,
1156             {
1157               {0, 8192, &MPIR_Pipelined_Bcast_Zcpy_MV2, 8},
1158               {8192, 16384, &MPIR_Pipelined_Bcast_Zcpy_MV2, 4},
1159               {16384, 65536, &MPIR_Pipelined_Bcast_Zcpy_MV2, 2},
1160               {65536, 524288, &MPIR_Pipelined_Bcast_MV2, -1},
1161               {524288, -1, &MPIR_Bcast_scatter_ring_allgather_shm_MV2, -1}
1162             },
1163             5,
1164             {
1165               {0, 8192, &MPIR_Shmem_Bcast_MV2, 8},
1166               {8192, 16384, &MPIR_Shmem_Bcast_MV2, 4},
1167               {16384, 65536, &MPIR_Shmem_Bcast_MV2, 2},
1168               {65536, 524288, &MPIR_Shmem_Bcast_MV2, -1},
1169               {524288, -1, &MPIR_Shmem_Bcast_MV2, -1}
1170             }
1171     },
1172     {
1173             2048,
1174             8192, 4, 4,
1175             {1, 1, 1, 1, 1, 1, 1},
1176             7,
1177             {
1178               {0, 16, &MPIR_Pipelined_Bcast_Zcpy_MV2, 8},
1179               {16, 32, &MPIR_Pipelined_Bcast_Zcpy_MV2, 4},
1180               {32, 4096, &MPIR_Pipelined_Bcast_Zcpy_MV2, 8},
1181               {4096, 16384, &MPIR_Pipelined_Bcast_Zcpy_MV2, 4},
1182               {16384, 32768, &MPIR_Pipelined_Bcast_Zcpy_MV2, 2},
1183               {32768, 524288, &MPIR_Pipelined_Bcast_MV2, -1},
1184               {524288, -1, &MPIR_Bcast_scatter_ring_allgather_shm_MV2, -1}
1185             },
1186             7,
1187             {
1188               {0, 16, &MPIR_Shmem_Bcast_MV2, 8},
1189               {16, 32, &MPIR_Shmem_Bcast_MV2, 4},
1190               {32, 4096, &MPIR_Shmem_Bcast_MV2, 8},
1191               {4096, 16384, &MPIR_Shmem_Bcast_MV2, 4},
1192               {16384, 32768, &MPIR_Shmem_Bcast_MV2, 2},
1193               {32768, 524288, &MPIR_Shmem_Bcast_MV2, -1},
1194               {524288, -1, &MPIR_Shmem_Bcast_MV2, -1}
1195             }
1196     }
1197   };
1198
1199         memcpy(mv2_bcast_thresholds_table, mv2_tmp_bcast_thresholds_table,
1200                     mv2_size_bcast_tuning_table * sizeof (mv2_bcast_tuning_table));
1201 }*/
1202
1203
1204 /************ Reduce variables and initializers                        */
1205
1206 typedef struct {
1207   int min;
1208   int max;
1209   int (*MV2_pt_Reduce_function)(void *sendbuf,
1210       void *recvbuf,
1211       int count,
1212       MPI_Datatype datatype,
1213       MPI_Op op,
1214       int root,
1215       MPI_Comm  comm_ptr);
1216 } mv2_reduce_tuning_element;
1217
1218 typedef struct {
1219   int numproc;
1220   int inter_k_degree;
1221   int intra_k_degree;
1222   int is_two_level_reduce[MV2_MAX_NB_THRESHOLDS];
1223   int size_inter_table;
1224   mv2_reduce_tuning_element inter_leader[MV2_MAX_NB_THRESHOLDS];
1225   int size_intra_table;
1226   mv2_reduce_tuning_element intra_node[MV2_MAX_NB_THRESHOLDS];
1227 } mv2_reduce_tuning_table;
1228
1229 int mv2_size_reduce_tuning_table = 0;
1230 mv2_reduce_tuning_table *mv2_reduce_thresholds_table = NULL;
1231
1232
1233 int mv2_reduce_intra_knomial_factor = -1;
1234 int mv2_reduce_inter_knomial_factor = -1;
1235
1236 int (*MV2_Reduce_function)( void *sendbuf,
1237     void *recvbuf,
1238     int count,
1239     MPI_Datatype datatype,
1240     MPI_Op op,
1241     int root,
1242     MPI_Comm  comm_ptr)=NULL;
1243
1244 int (*MV2_Reduce_intra_function)( void *sendbuf,
1245     void *recvbuf,
1246     int count,
1247     MPI_Datatype datatype,
1248     MPI_Op op,
1249     int root,
1250     MPI_Comm  comm_ptr)=NULL;
1251
1252
1253 #define MPIR_Reduce_inter_knomial_wrapper_MV2 smpi_coll_tuned_reduce_binomial
1254 #define MPIR_Reduce_intra_knomial_wrapper_MV2 smpi_coll_tuned_reduce_binomial
1255 #define MPIR_Reduce_binomial_MV2 smpi_coll_tuned_reduce_binomial
1256 #define MPIR_Reduce_redscat_gather_MV2 smpi_coll_tuned_reduce_scatter_gather
1257 #define MPIR_Reduce_shmem_MV2 smpi_coll_tuned_reduce_ompi_basic_linear
1258
1259
1260
1261 static void init_mv2_reduce_tables_stampede(){
1262   /*Stampede*/
1263   mv2_size_reduce_tuning_table = 8;
1264   mv2_reduce_thresholds_table = xbt_malloc(mv2_size_reduce_tuning_table *
1265       sizeof (mv2_reduce_tuning_table));
1266   mv2_reduce_tuning_table mv2_tmp_reduce_thresholds_table[] = {
1267       {
1268           16,
1269           4,
1270           4,
1271           {1, 0, 0},
1272           3,
1273           {
1274               {0, 262144, &MPIR_Reduce_inter_knomial_wrapper_MV2},
1275               {262144, 1048576, &MPIR_Reduce_binomial_MV2},
1276               {1048576, -1, &MPIR_Reduce_redscat_gather_MV2},
1277           },
1278           2,
1279           {
1280               {0, 65536, &MPIR_Reduce_shmem_MV2},
1281               {65536,-1,  &MPIR_Reduce_binomial_MV2},
1282           },
1283       },
1284       {
1285           32,
1286           4,
1287           4,
1288           {1, 1, 1, 1, 0, 0, 0},
1289           7,
1290           {
1291               {0, 8192, &MPIR_Reduce_inter_knomial_wrapper_MV2},
1292               {8192, 16384, &MPIR_Reduce_inter_knomial_wrapper_MV2},
1293               {16384, 32768, &MPIR_Reduce_inter_knomial_wrapper_MV2},
1294               {32768, 65536, &MPIR_Reduce_binomial_MV2},
1295               {65536, 262144, &MPIR_Reduce_inter_knomial_wrapper_MV2},
1296               {262144, 1048576, &MPIR_Reduce_binomial_MV2},
1297               {1048576, -1, &MPIR_Reduce_redscat_gather_MV2},
1298           },
1299           6,
1300           {
1301               {0, 8192, &MPIR_Reduce_shmem_MV2},
1302               {8192, 16384, &MPIR_Reduce_intra_knomial_wrapper_MV2},
1303               {16384, 32768, &MPIR_Reduce_shmem_MV2},
1304               {32768, 65536, &MPIR_Reduce_shmem_MV2},
1305               {65536, 262144, &MPIR_Reduce_shmem_MV2},
1306               {262144,-1,  &MPIR_Reduce_binomial_MV2},
1307           },
1308       },
1309       {
1310           64,
1311           4,
1312           4,
1313           {1, 1, 1, 1, 0},
1314           5,
1315           {
1316               {0, 8192, &MPIR_Reduce_inter_knomial_wrapper_MV2},
1317               {8192, 16384, &MPIR_Reduce_inter_knomial_wrapper_MV2},
1318               {16384, 65536, &MPIR_Reduce_binomial_MV2},
1319               {65536, 262144, &MPIR_Reduce_inter_knomial_wrapper_MV2},
1320               {262144, -1, &MPIR_Reduce_redscat_gather_MV2},
1321           },
1322           5,
1323           {
1324               {0, 8192, &MPIR_Reduce_shmem_MV2},
1325               {8192, 16384, &MPIR_Reduce_intra_knomial_wrapper_MV2},
1326               {16384, 65536, &MPIR_Reduce_shmem_MV2},
1327               {65536, 262144, &MPIR_Reduce_intra_knomial_wrapper_MV2},
1328               {262144, -1, &MPIR_Reduce_binomial_MV2},
1329           },
1330       },
1331       {
1332           128,
1333           4,
1334           4,
1335           {1, 0, 1, 0, 1, 0},
1336           6,
1337           {
1338               {0, 8192, &MPIR_Reduce_inter_knomial_wrapper_MV2},
1339               {8192, 16384, &MPIR_Reduce_inter_knomial_wrapper_MV2},
1340               {16384, 65536, &MPIR_Reduce_binomial_MV2},
1341               {65536, 262144, &MPIR_Reduce_inter_knomial_wrapper_MV2},
1342               {262144, 1048576, &MPIR_Reduce_binomial_MV2},
1343               {1048576, -1, &MPIR_Reduce_redscat_gather_MV2},
1344           },
1345           5,
1346           {
1347               {0, 8192, &MPIR_Reduce_shmem_MV2},
1348               {8192, 16384, &MPIR_Reduce_intra_knomial_wrapper_MV2},
1349               {16384, 65536, &MPIR_Reduce_shmem_MV2},
1350               {65536, 262144, &MPIR_Reduce_intra_knomial_wrapper_MV2},
1351               {262144, -1, &MPIR_Reduce_binomial_MV2},
1352           },
1353       },
1354       {
1355           256,
1356           4,
1357           4,
1358           {1, 1, 1, 0, 1, 1, 0},
1359           7,
1360           {
1361               {0, 8192, &MPIR_Reduce_inter_knomial_wrapper_MV2},
1362               {8192, 16384, &MPIR_Reduce_inter_knomial_wrapper_MV2},
1363               {16384, 32768, &MPIR_Reduce_binomial_MV2},
1364               {32768, 65536, &MPIR_Reduce_binomial_MV2},
1365               {65536, 262144, &MPIR_Reduce_binomial_MV2},
1366               {262144, 1048576, &MPIR_Reduce_binomial_MV2},
1367               {1048576, -1, &MPIR_Reduce_redscat_gather_MV2},
1368           },
1369           6,
1370           {
1371               {0, 8192, &MPIR_Reduce_shmem_MV2},
1372               {8192, 16384, &MPIR_Reduce_intra_knomial_wrapper_MV2},
1373               {16384, 32768, &MPIR_Reduce_shmem_MV2},
1374               {32768, 65536, &MPIR_Reduce_shmem_MV2},
1375               {65536, 262144, &MPIR_Reduce_intra_knomial_wrapper_MV2},
1376               {262144, -1, &MPIR_Reduce_binomial_MV2},
1377           },
1378       },
1379       {
1380           512,
1381           4,
1382           4,
1383           {1, 0, 1, 1, 1, 0},
1384           6,
1385           {
1386               {0, 8192, &MPIR_Reduce_inter_knomial_wrapper_MV2},
1387               {8192, 16384, &MPIR_Reduce_inter_knomial_wrapper_MV2},
1388               {16384, 65536, &MPIR_Reduce_binomial_MV2},
1389               {65536, 262144, &MPIR_Reduce_binomial_MV2},
1390               {262144, 1048576, &MPIR_Reduce_binomial_MV2},
1391               {1048576, -1, &MPIR_Reduce_redscat_gather_MV2},
1392           },
1393           5,
1394           {
1395               {0, 8192, &MPIR_Reduce_shmem_MV2},
1396               {8192, 16384, &MPIR_Reduce_intra_knomial_wrapper_MV2},
1397               {16384, 65536, &MPIR_Reduce_shmem_MV2},
1398               {65536, 262144, &MPIR_Reduce_intra_knomial_wrapper_MV2},
1399               {262144, -1, &MPIR_Reduce_binomial_MV2},
1400           },
1401       },
1402       {
1403           1024,
1404           4,
1405           4,
1406           {1, 0, 1, 1, 1},
1407           5,
1408           {
1409               {0, 8192, &MPIR_Reduce_inter_knomial_wrapper_MV2},
1410               {8192, 16384, &MPIR_Reduce_inter_knomial_wrapper_MV2},
1411               {16384, 65536, &MPIR_Reduce_binomial_MV2},
1412               {65536, 262144, &MPIR_Reduce_binomial_MV2},
1413               {262144, -1, &MPIR_Reduce_binomial_MV2},
1414           },
1415           5,
1416           {
1417               {0, 8192, &MPIR_Reduce_shmem_MV2},
1418               {8192, 16384, &MPIR_Reduce_intra_knomial_wrapper_MV2},
1419               {16384, 65536, &MPIR_Reduce_shmem_MV2},
1420               {65536, 262144, &MPIR_Reduce_intra_knomial_wrapper_MV2},
1421               {262144, -1, &MPIR_Reduce_binomial_MV2},
1422           },
1423       },
1424       {
1425           2048,
1426           4,
1427           4,
1428           {1, 0, 1, 1, 1,1},
1429           6,
1430           {
1431               {0, 2048, &MPIR_Reduce_inter_knomial_wrapper_MV2},
1432               {2048, 4096, &MPIR_Reduce_inter_knomial_wrapper_MV2},
1433               {4096, 16384, &MPIR_Reduce_binomial_MV2},
1434               {16384, 65536, &MPIR_Reduce_binomial_MV2},
1435               {65536, 131072, &MPIR_Reduce_binomial_MV2},
1436               {131072, -1, &MPIR_Reduce_binomial_MV2},
1437           },
1438           6,
1439           {
1440               {0, 2048, &MPIR_Reduce_shmem_MV2},
1441               {2048, 4096, &MPIR_Reduce_shmem_MV2},
1442               {4096, 16384, &MPIR_Reduce_shmem_MV2},
1443               {16384, 65536, &MPIR_Reduce_intra_knomial_wrapper_MV2},
1444               {65536, 131072, &MPIR_Reduce_binomial_MV2},
1445               {131072, -1, &MPIR_Reduce_shmem_MV2},
1446           },
1447       },
1448
1449   };
1450   memcpy(mv2_reduce_thresholds_table, mv2_tmp_reduce_thresholds_table,
1451       mv2_size_reduce_tuning_table * sizeof (mv2_reduce_tuning_table));
1452 }
1453
1454 /************ Reduce scatter variables and initializers                        */
1455
1456 typedef struct {
1457   int min;
1458   int max;
1459   int (*MV2_pt_Red_scat_function)(void *sendbuf,
1460       void *recvbuf,
1461       int *recvcnts,
1462       MPI_Datatype datatype,
1463       MPI_Op op,
1464       MPI_Comm comm_ptr);
1465 } mv2_red_scat_tuning_element;
1466
1467 typedef struct {
1468   int numproc;
1469   int size_inter_table;
1470   mv2_red_scat_tuning_element inter_leader[MV2_MAX_NB_THRESHOLDS];
1471 } mv2_red_scat_tuning_table;
1472
1473 int mv2_size_red_scat_tuning_table = 0;
1474 mv2_red_scat_tuning_table *mv2_red_scat_thresholds_table = NULL;
1475
1476
1477 int (*MV2_Red_scat_function)(void *sendbuf,
1478     void *recvbuf,
1479     int *recvcnts,
1480     MPI_Datatype datatype,
1481     MPI_Op op,
1482     MPI_Comm comm_ptr);
1483
1484
1485
1486 static  int MPIR_Reduce_Scatter_Basic_MV2(void *sendbuf,
1487     void *recvbuf,
1488     int *recvcnts,
1489     MPI_Datatype datatype,
1490     MPI_Op op,
1491     MPI_Comm comm)
1492 {
1493   smpi_mpi_reduce_scatter(sendbuf,recvbuf,recvcnts,datatype,op,comm);
1494   return MPI_SUCCESS;
1495 }
1496 #define MPIR_Reduce_scatter_non_comm_MV2 smpi_coll_tuned_reduce_scatter_mpich_noncomm
1497 #define MPIR_Reduce_scatter_Rec_Halving_MV2 smpi_coll_tuned_reduce_scatter_ompi_basic_recursivehalving
1498 #define MPIR_Reduce_scatter_Pair_Wise_MV2 smpi_coll_tuned_reduce_scatter_mpich_pair
1499
1500
1501
1502
1503 static void init_mv2_reduce_scatter_tables_stampede(){
1504   mv2_size_red_scat_tuning_table = 6;
1505   mv2_red_scat_thresholds_table = xbt_malloc(mv2_size_red_scat_tuning_table *
1506       sizeof (mv2_red_scat_tuning_table));
1507   mv2_red_scat_tuning_table mv2_tmp_red_scat_thresholds_table[] = {
1508       {
1509           16,
1510           3,
1511           {
1512               {0, 64, &MPIR_Reduce_Scatter_Basic_MV2},
1513               {64, 65536, &MPIR_Reduce_scatter_Rec_Halving_MV2},
1514               {65536, -1, &MPIR_Reduce_scatter_Pair_Wise_MV2},
1515           },
1516       },
1517       {
1518           32,
1519           3,
1520           {
1521               {0, 64, &MPIR_Reduce_Scatter_Basic_MV2},
1522               {64, 131072, &MPIR_Reduce_scatter_Rec_Halving_MV2},
1523               {131072, -1, &MPIR_Reduce_scatter_Pair_Wise_MV2},
1524           },
1525       },
1526       {
1527           64,
1528           3,
1529           {
1530               {0, 1024, &MPIR_Reduce_Scatter_Basic_MV2},
1531               {1024, 262144, &MPIR_Reduce_scatter_Rec_Halving_MV2},
1532               {262144, -1, &MPIR_Reduce_scatter_Pair_Wise_MV2},
1533           },
1534       },
1535       {
1536           128,
1537           2,
1538           {
1539               {0, 128, &MPIR_Reduce_Scatter_Basic_MV2},
1540               {128, -1, &MPIR_Reduce_scatter_Rec_Halving_MV2},
1541           },
1542       },
1543       {
1544           256,
1545           2,
1546           {
1547               {0, 128, &MPIR_Reduce_Scatter_Basic_MV2},
1548               {128, -1, &MPIR_Reduce_scatter_Rec_Halving_MV2},
1549           },
1550       },
1551       {
1552           512,
1553           2,
1554           {
1555               {0, 256, &MPIR_Reduce_Scatter_Basic_MV2},
1556               {256, -1, &MPIR_Reduce_scatter_Rec_Halving_MV2},
1557           },
1558       },
1559
1560   };
1561   memcpy(mv2_red_scat_thresholds_table, mv2_tmp_red_scat_thresholds_table,
1562       mv2_size_red_scat_tuning_table * sizeof (mv2_red_scat_tuning_table));
1563 }
1564
1565 /************ Scatter variables and initializers                        */
1566
1567 typedef struct {
1568   int min;
1569   int max;
1570   int (*MV2_pt_Scatter_function)(void *sendbuf,
1571       int sendcnt,
1572       MPI_Datatype sendtype,
1573       void *recvbuf,
1574       int recvcnt,
1575       MPI_Datatype recvtype,
1576       int root, MPI_Comm comm);
1577 } mv2_scatter_tuning_element;
1578
1579 typedef struct {
1580   int numproc;
1581   int size_inter_table;
1582   mv2_scatter_tuning_element inter_leader[MV2_MAX_NB_THRESHOLDS];
1583   int size_intra_table;
1584   mv2_scatter_tuning_element intra_node[MV2_MAX_NB_THRESHOLDS];
1585 } mv2_scatter_tuning_table;
1586
1587
1588 int *mv2_scatter_table_ppn_conf = NULL;
1589 int mv2_scatter_num_ppn_conf = 1;
1590 int *mv2_size_scatter_tuning_table = NULL;
1591 mv2_scatter_tuning_table **mv2_scatter_thresholds_table = NULL;
1592
1593 int (*MV2_Scatter_function) (void *sendbuf, int sendcount, MPI_Datatype sendtype,
1594     void *recvbuf, int recvcount, MPI_Datatype recvtype,
1595     int root, MPI_Comm comm)=NULL;
1596
1597 int (*MV2_Scatter_intra_function) (void *sendbuf, int sendcount, MPI_Datatype sendtype,
1598     void *recvbuf, int recvcount, MPI_Datatype recvtype,
1599     int root, MPI_Comm comm)=NULL;
1600 int MPIR_Scatter_mcst_wrap_MV2(void *sendbuf,
1601     int sendcnt,
1602     MPI_Datatype sendtype,
1603     void *recvbuf,
1604     int recvcnt,
1605     MPI_Datatype recvtype,
1606     int root, MPI_Comm comm_ptr);
1607
1608 int MPIR_Scatter_mcst_wrap_MV2(void *sendbuf,
1609     int sendcnt,
1610     MPI_Datatype sendtype,
1611     void *recvbuf,
1612     int recvcnt,
1613     MPI_Datatype recvtype,
1614     int root, MPI_Comm comm_ptr)
1615 {
1616   return 0;
1617 }
1618
1619 #define MPIR_Scatter_MV2_Binomial smpi_coll_tuned_scatter_ompi_binomial
1620 #define MPIR_Scatter_MV2_Direct smpi_coll_tuned_scatter_ompi_basic_linear
1621 #define MPIR_Scatter_MV2_two_level_Binomial smpi_coll_tuned_scatter_ompi_binomial
1622 #define MPIR_Scatter_MV2_two_level_Direct smpi_coll_tuned_scatter_ompi_basic_linear
1623
1624
1625
1626
1627 static void init_mv2_scatter_tables_stampede(){
1628   {
1629     int agg_table_sum = 0;
1630     int i;
1631     mv2_scatter_tuning_table **table_ptrs = NULL;
1632     mv2_scatter_num_ppn_conf = 3;
1633     mv2_scatter_thresholds_table
1634     = xbt_malloc(sizeof(mv2_scatter_tuning_table *)
1635         * mv2_scatter_num_ppn_conf);
1636     table_ptrs = xbt_malloc(sizeof(mv2_scatter_tuning_table *)
1637         * mv2_scatter_num_ppn_conf);
1638     mv2_size_scatter_tuning_table = xbt_malloc(sizeof(int) *
1639         mv2_scatter_num_ppn_conf);
1640     mv2_scatter_table_ppn_conf
1641     = xbt_malloc(mv2_scatter_num_ppn_conf * sizeof(int));
1642     mv2_scatter_table_ppn_conf[0] = 1;
1643     mv2_size_scatter_tuning_table[0] = 6;
1644     mv2_scatter_tuning_table mv2_tmp_scatter_thresholds_table_1ppn[] = {
1645         {2,
1646             1,
1647             {
1648                 {0, -1, &MPIR_Scatter_MV2_Binomial},
1649             },
1650             1,
1651             {
1652                 {0, -1, &MPIR_Scatter_MV2_Binomial},
1653             },
1654         },
1655
1656         {4,
1657             1,
1658             {
1659                 {0, -1, &MPIR_Scatter_MV2_Direct},
1660             },
1661             1,
1662             {
1663                 {0, -1, &MPIR_Scatter_MV2_Direct},
1664             },
1665         },
1666
1667         {8,
1668             1,
1669             {
1670                 {0, -1, &MPIR_Scatter_MV2_Direct},
1671             },
1672             1,
1673             {
1674                 {0, -1, &MPIR_Scatter_MV2_Direct},
1675             },
1676         },
1677
1678         {16,
1679             1,
1680             {
1681                 {0, -1, &MPIR_Scatter_MV2_Direct},
1682             },
1683             1,
1684             {
1685                 {0, -1, &MPIR_Scatter_MV2_Direct},
1686             },
1687         },
1688
1689         {32,
1690             1,
1691             {
1692                 {0, -1, &MPIR_Scatter_MV2_Direct},
1693             },
1694             1,
1695             {
1696                 {0, -1, &MPIR_Scatter_MV2_Direct},
1697             },
1698         },
1699
1700         {64,
1701             2,
1702             {
1703                 {0, 32, &MPIR_Scatter_MV2_Binomial},
1704                 {32, -1, &MPIR_Scatter_MV2_Direct},
1705             },
1706             1,
1707             {
1708                 {0, -1, &MPIR_Scatter_MV2_Binomial},
1709             },
1710         },
1711     };
1712     table_ptrs[0] = mv2_tmp_scatter_thresholds_table_1ppn;
1713     mv2_scatter_table_ppn_conf[1] = 2;
1714     mv2_size_scatter_tuning_table[1] = 6;
1715     mv2_scatter_tuning_table mv2_tmp_scatter_thresholds_table_2ppn[] = {
1716         {4,
1717             2,
1718             {
1719                 {0, 4096, &MPIR_Scatter_MV2_Binomial},
1720                 {4096, -1, &MPIR_Scatter_MV2_Direct},
1721             },
1722             1,
1723             {
1724                 {0, -1, &MPIR_Scatter_MV2_Direct},
1725             },
1726         },
1727
1728         {8,
1729             2,
1730             {
1731                 {0, 512, &MPIR_Scatter_MV2_two_level_Direct},
1732                 {512, -1, &MPIR_Scatter_MV2_Direct},
1733             },
1734             1,
1735             {
1736                 {0, -1, &MPIR_Scatter_MV2_Binomial},
1737             },
1738         },
1739
1740         {16,
1741             2,
1742             {
1743                 {0, 2048, &MPIR_Scatter_MV2_two_level_Direct},
1744                 {2048, -1, &MPIR_Scatter_MV2_Direct},
1745             },
1746             1,
1747             {
1748                 {0, -1, &MPIR_Scatter_MV2_Binomial},
1749             },
1750         },
1751
1752         {32,
1753             2,
1754             {
1755                 {0, 2048, &MPIR_Scatter_MV2_two_level_Direct},
1756                 {2048, -1, &MPIR_Scatter_MV2_Direct},
1757             },
1758             1,
1759             {
1760                 {0, -1, &MPIR_Scatter_MV2_Binomial},
1761             },
1762         },
1763
1764         {64,
1765             2,
1766             {
1767                 {0, 8192, &MPIR_Scatter_MV2_two_level_Direct},
1768                 {8192, -1, &MPIR_Scatter_MV2_Direct},
1769             },
1770             1,
1771             {
1772                 {0, -1, &MPIR_Scatter_MV2_Binomial},
1773             },
1774         },
1775
1776         {128,
1777             4,
1778             {
1779                 {0, 16, &MPIR_Scatter_MV2_Binomial},
1780                 {16, 128, &MPIR_Scatter_MV2_two_level_Binomial},
1781                 {128, 16384, &MPIR_Scatter_MV2_two_level_Direct},
1782                 {16384, -1, &MPIR_Scatter_MV2_Direct},
1783             },
1784             1,
1785             {
1786                 {0, 128, &MPIR_Scatter_MV2_Direct},
1787                 {128, -1, &MPIR_Scatter_MV2_Binomial},
1788             },
1789         },
1790     };
1791     table_ptrs[1] = mv2_tmp_scatter_thresholds_table_2ppn;
1792     mv2_scatter_table_ppn_conf[2] = 16;
1793     mv2_size_scatter_tuning_table[2] = 8;
1794     mv2_scatter_tuning_table mv2_tmp_scatter_thresholds_table_16ppn[] = {
1795         {
1796             16,
1797             2,
1798             {
1799                 {0, 256, &MPIR_Scatter_MV2_Binomial},
1800                 {256, -1, &MPIR_Scatter_MV2_Direct},
1801             },
1802             1,
1803             {
1804                 { 0, -1, &MPIR_Scatter_MV2_Direct},
1805             },
1806         },
1807
1808         {
1809             32,
1810             2,
1811             {
1812                 {0, 512, &MPIR_Scatter_MV2_Binomial},
1813                 {512, -1, &MPIR_Scatter_MV2_Direct},
1814             },
1815             1,
1816             {
1817                 { 0, -1, &MPIR_Scatter_MV2_Direct},
1818             },
1819         },
1820
1821         {
1822             64,
1823             2,
1824             {
1825                 {0, 1024, &MPIR_Scatter_MV2_two_level_Direct},
1826                 {1024, -1, &MPIR_Scatter_MV2_Direct},
1827             },
1828             1,
1829             {
1830                 { 0, -1, &MPIR_Scatter_MV2_Direct},
1831             },
1832         },
1833
1834         {
1835             128,
1836             4,
1837             {
1838                 {0, 16, &MPIR_Scatter_mcst_wrap_MV2},
1839                 {0, 16, &MPIR_Scatter_MV2_two_level_Direct},
1840                 {16, 2048, &MPIR_Scatter_MV2_two_level_Direct},
1841                 {2048, -1, &MPIR_Scatter_MV2_Direct},
1842             },
1843             1,
1844             {
1845                 { 0, -1, &MPIR_Scatter_MV2_Direct},
1846             },
1847         },
1848
1849         {
1850             256,
1851             4,
1852             {
1853                 {0, 16, &MPIR_Scatter_mcst_wrap_MV2},
1854                 {0, 16, &MPIR_Scatter_MV2_two_level_Direct},
1855                 {16, 2048, &MPIR_Scatter_MV2_two_level_Direct},
1856                 {2048, -1,  &MPIR_Scatter_MV2_Direct},
1857             },
1858             1,
1859             {
1860                 { 0, -1, &MPIR_Scatter_MV2_Direct},
1861             },
1862         },
1863
1864         {
1865             512,
1866             4,
1867             {
1868                 {0, 16, &MPIR_Scatter_mcst_wrap_MV2},
1869                 {16, 16, &MPIR_Scatter_MV2_two_level_Direct},
1870                 {16, 4096, &MPIR_Scatter_MV2_two_level_Direct},
1871                 {4096, -1, &MPIR_Scatter_MV2_Direct},
1872             },
1873             1,
1874             {
1875                 { 0, -1, &MPIR_Scatter_MV2_Binomial},
1876             },
1877         },
1878         {
1879             1024,
1880             5,
1881             {
1882                 {0, 16, &MPIR_Scatter_mcst_wrap_MV2},
1883                 {0, 16,  &MPIR_Scatter_MV2_Binomial},
1884                 {16, 32, &MPIR_Scatter_MV2_Binomial},
1885                 {32, 4096, &MPIR_Scatter_MV2_two_level_Direct},
1886                 {4096, -1, &MPIR_Scatter_MV2_Direct},
1887             },
1888             1,
1889             {
1890                 { 0, -1, &MPIR_Scatter_MV2_Binomial},
1891             },
1892         },
1893         {
1894             2048,
1895             7,
1896             {
1897                 {0, 16, &MPIR_Scatter_mcst_wrap_MV2},
1898                 {0, 16,  &MPIR_Scatter_MV2_two_level_Binomial},
1899                 {16, 128, &MPIR_Scatter_MV2_two_level_Binomial},
1900                 {128, 1024, &MPIR_Scatter_MV2_two_level_Direct},
1901                 {1024, 16384, &MPIR_Scatter_MV2_two_level_Direct},
1902                 {16384, 65536, &MPIR_Scatter_MV2_Direct},
1903                 {65536, -1, &MPIR_Scatter_MV2_two_level_Direct},
1904             },
1905             6,
1906             {
1907                 {0, 16, &MPIR_Scatter_MV2_Binomial},
1908                 {16, 128, &MPIR_Scatter_MV2_Binomial},
1909                 {128, 1024, &MPIR_Scatter_MV2_Binomial},
1910                 {1024, 16384, &MPIR_Scatter_MV2_Direct},
1911                 {16384, 65536, &MPIR_Scatter_MV2_Direct},
1912                 {65536, -1, &MPIR_Scatter_MV2_Direct},
1913             },
1914         },
1915     };
1916     table_ptrs[2] = mv2_tmp_scatter_thresholds_table_16ppn;
1917     agg_table_sum = 0;
1918     for (i = 0; i < mv2_scatter_num_ppn_conf; i++) {
1919         agg_table_sum += mv2_size_scatter_tuning_table[i];
1920     }
1921     mv2_scatter_thresholds_table[0] =
1922         xbt_malloc(agg_table_sum * sizeof (mv2_scatter_tuning_table));
1923     memcpy(mv2_scatter_thresholds_table[0], table_ptrs[0],
1924         (sizeof(mv2_scatter_tuning_table)
1925             * mv2_size_scatter_tuning_table[0]));
1926     for (i = 1; i < mv2_scatter_num_ppn_conf; i++) {
1927         mv2_scatter_thresholds_table[i] =
1928             mv2_scatter_thresholds_table[i - 1]
1929                                          + mv2_size_scatter_tuning_table[i - 1];
1930         memcpy(mv2_scatter_thresholds_table[i], table_ptrs[i],
1931             (sizeof(mv2_scatter_tuning_table)
1932                 * mv2_size_scatter_tuning_table[i]));
1933     }
1934     xbt_free(table_ptrs);
1935   }
1936 }
1937