PRACE NPT

/****************************************************************************/

/* SELFISHDETOUR:selfishdetour-info */

/*     This file is part of Selfish Detour: OS detour(noise) benchmark

 */

/* SELFISHDETOUR:selfishdetour-info */

/* */

/* SELFISHDETOUR:selfishdetour-fillin */

/*     $Id: bench_worst_best.c,v 1.10 2007/01/03 21:16:49 kazutomo Exp $

 *     SelfishDetour_Version: 1.0.7

 *     SelfishDetour_Heredity: FOSS_ORIG

 *     SelfishDetour_License: GPL

 */

/* SELFISHDETOUR:selfishdetour-fillin */

/* */

/* SELFISHDETOUR:selfishdetour-gpl */

/*      Copyright: Argonne National Laboratory, Department of Energy,

 *                 and University of Chicago.  2004, 2005, 2006, 2007

 *      SelfishDetour License: GPL

 *

 *      This software is free.  See the file license-files/license.GPL

 *      for complete details on your rights to copy, modify, and use this

 *      software.

 */

/* SELFISHDETOUR:selfishdetour-gpl */

/****************************************************************************/

/*

  best-worst benchmark

*/

#include <stdlib.h>

#include <sys/time.h>

#include <signal.h>

#include <unistd.h>

#include <stdio.h>

#include <time.h>

#include <errno.h>

#include <stdarg.h>

#include <values.h>

#include <limits.h>

#include "mpi.h"

#include "selfish_detour.h"

#define  COMP_WINDOW_USEC (0)

#define  TIMEOUT_SEC      (10)

static int rank0_printf( const char* fmt, ...);

static double busy_loop_cnt_per_sec;

/*

  busy_loop_cnt_per_sec is adjusted before main

 */

void calibrate_busy_loop_cnt() __attribute__( (constructor) );

void calibrate_busy_loop_cnt()

{

  unsigned long long s,b;

  int time_to_calibrate = 5;

  unsigned long long delay_ticks = (unsigned long long)time_to_calibrate*1000*1000*TICKS_PER_US;

  double x;

  double fixed_work;

  fixed_work = MAXDOUBLE;

  x = 0.0;

  s = rdtsc();

  b = s;

  while ( (b-s)<delay_ticks && x<fixed_work ) {

    x++;

    b = rdtsc();

  }

  busy_loop_cnt_per_sec = x/(double)time_to_calibrate;

}

static void busy_loop(unsigned wait_usec)

{

  unsigned long long delay_ticks = ULONG_LONG_MAX;

  unsigned long long s,b;

  double x;

  double fixed_work  = busy_loop_cnt_per_sec*wait_usec/1000.0/1000.0;

  x = 0.0;

  s = rdtsc();

  b = s;

  /* busy waiting loop itself is exactly same as the loop in the

     calibration function */

  while ( (b-s)<delay_ticks && x<fixed_work ) {

    x++;

    b = rdtsc();

  }

}

static void myfunc(double *in, double *inout, int *len, MPI_Datatype *dptr) {

  int i;

  for (i=0; i<*len; i++) {

    *inout = *in + *inout;

    in++; inout++;

  }

}

static double benchloop(int mode, int* n_iters)

{

  int i;

  MPI_Op myOp;

  double   in=1.0, out;  /* for AllReduce */

  double   t1,t2;

  int  cnt,n;

  int  timeouted_in, timeouted_out;

  int size;

  MPI_Op_create( (MPI_User_function *) myfunc, 1, &myOp );

  MPI_Barrier(MPI_COMM_WORLD);

  MPI_Comm_size(MPI_COMM_WORLD, &size);

  selfish_detour_init();

  t1 = MPI_Wtime();

  cnt = 0;

  for(i=0; ;i++) {

    if( COMP_WINDOW_USEC > 0 )

      busy_loop(COMP_WINDOW_USEC);

    switch( mode ) {

    case 0:

      busy_loop(100);  /* when no noise, it will be 100 usec busyloop. */

      break;

    case 1:

      MPI_Allreduce(&in, &out, 1, MPI_DOUBLE, myOp, MPI_COMM_WORLD);

      break;

    }

    if( (MPI_Wtime()-t1) > (double)TIMEOUT_SEC ) {

      timeouted_in = 1;

    } else {

      timeouted_in = 0;

    }

    MPI_Allreduce(&timeouted_in, &timeouted_out, 1,

                  MPI_INT, MPI_SUM, MPI_COMM_WORLD);

    if( timeouted_out == size ) {

      break;

    }

  }

  t2 = MPI_Wtime();

  selfish_detour_finalize();

  *n_iters = n = i*2;  /* the reason why i is doubled is that the

                          above calibration loop does allreduce twice

                          when mode is 1.  this is a kind of

                          approximation. */

  rank0_printf("# N_ITERS=%d\n",n);

  selfish_detour_init();

  t1 = MPI_Wtime();

  for(i=0; i<n; i++) {

    if( COMP_WINDOW_USEC > 0 )

      busy_loop(COMP_WINDOW_USEC);

    switch( mode ) {

    case 0:

      busy_loop(100);

      break;

    case 1:

      MPI_Allreduce(&in, &out, 1, MPI_DOUBLE, myOp, MPI_COMM_WORLD);

      break;

    }

  }

  t2 = MPI_Wtime();

  selfish_detour_finalize();

  return (t2-t1);

}

static void testloop(int mode)

{

  double elapsed_sec;

  unsigned n_iters;

  int size;

  MPI_Comm_size(MPI_COMM_WORLD, &size);

  elapsed_sec = benchloop(mode, &n_iters);

  rank0_printf("# e=%f\n", elapsed_sec);

  rank0_printf("# %s ", (mode==0)?"BEST":"WORST" );

  rank0_printf("N=%d ", size);

  rank0_printf("TIME_PER_ITERATION=%f usec ",

               (double)elapsed_sec*1000.0*1000.0/(double)n_iters);

  if( get_detour_noise_interval_usec() == 0 ) {

    rank0_printf("NO_NOISE ");

  } else {

    rank0_printf("I=%f D=%f ",

                 get_detour_noise_interval_usec(),

                 get_detour_noise_duration_usec() );

    if( get_detour_noise_counter() > 0 ) {

      rank0_printf("CNT=%d ",

                   get_detour_noise_counter() );

    } else {

      rank0_printf("P=%f ",

                   get_detour_noise_probability() );

    }

    if( get_detour_noise_sync()>0 ) {

      rank0_printf("SYNC ");

    }

  }

  rank0_printf("\n");

}

int main(int argc, char* argv[])

{

  MPI_Init(&argc, &argv);

  rank0_printf("# [bench_worst_best] v1.2  %s %s\n",

               __DATE__, __TIME__);

  testloop( 0 );

  testloop( 1 );

  rank0_printf("done.\n");

  MPI_Finalize();

  return 0;

}

static int rank0_printf(const char* fmt, ...)

{

  int rank;

  int ret=0;

  MPI_Comm_rank(MPI_COMM_WORLD, &rank);

  if( rank==0 ) {

    va_list ap;

    va_start(ap,fmt);

    ret = vprintf(fmt, ap);

    va_end(ap);

  }

  return ret;

}