src/smpi/smpi_bench.cpp

   1 /* Copyright (c) 2007, 2009-2017. The SimGrid Team. All rights reserved.    */
   2
   3 /* This program is free software; you can redistribute it and/or modify it
   4  * under the terms of the license (GNU LGPL) which comes with this package. */
   5
   6 #include <cstring>
   7
   8 #include <unordered_map>
   9 #include <utility>
  10
  11 #include "src/internal_config.h"
  12 #include "private.h"
  13 #include "private.hpp"
  14 #include <xbt/ex.hpp>
  15 #include "xbt/dict.h"
  16 #include "xbt/sysdep.h"
  17 #include "xbt/ex.h"
  18 #include "surf/surf.h"
  19 #include "simgrid/sg_config.h"
  20 #include "simgrid/modelchecker.h"
  21 #include "src/mc/mc_replay.h"
  22
  23 #include <sys/types.h>
  24 #ifndef WIN32
  25 #include <sys/mman.h>
  26 #endif
  27 #include <math.h> // sqrt
  28 #include <stdio.h>
  29
  30 #if HAVE_PAPI
  31 #include <papi.h>
  32 #endif
  33
  34 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(smpi_bench, smpi, "Logging specific to SMPI (benchmarking)");
  35
  36
  37 xbt_dict_t samples = nullptr;         /* Allocated on first use */
  38
  39 double smpi_cpu_threshold = -1;
  40 double smpi_host_speed;
  41
  42 shared_malloc_type smpi_cfg_shared_malloc = shmalloc_global;
  43 double smpi_total_benched_time = 0;
  44 smpi_privatisation_region_t smpi_privatisation_regions;
  45
  46 void smpi_bench_destroy()
  47 {
  48   xbt_dict_free(&samples);
  49 }
  50
  51 extern "C" XBT_PUBLIC(void) smpi_execute_flops_(double *flops);
  52 void smpi_execute_flops_(double *flops)
  53 {
  54   smpi_execute_flops(*flops);
  55 }
  56
  57 extern "C" XBT_PUBLIC(void) smpi_execute_(double *duration);
  58 void smpi_execute_(double *duration)
  59 {
  60   smpi_execute(*duration);
  61 }
  62
  63 void smpi_execute_flops(double flops) {
  64   XBT_DEBUG("Handle real computation time: %f flops", flops);
  65   smx_activity_t action = simcall_execution_start("computation", flops, 1, 0);
  66   simcall_set_category (action, TRACE_internal_smpi_get_category());
  67   simcall_execution_wait(action);
  68   smpi_switch_data_segment(smpi_process()->index());
  69 }
  70
  71 void smpi_execute(double duration)
  72 {
  73   if (duration >= smpi_cpu_threshold) {
  74     XBT_DEBUG("Sleep for %g to handle real computation time", duration);
  75     double flops = duration * smpi_host_speed;
  76     int rank = smpi_process()->index();
  77     instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
  78     extra->type=TRACING_COMPUTING;
  79     extra->comp_size=flops;
  80     TRACE_smpi_computing_in(rank, extra);
  81
  82     smpi_execute_flops(flops);
  83
  84     TRACE_smpi_computing_out(rank);
  85
  86   } else {
  87     XBT_DEBUG("Real computation took %g while option smpi/cpu_threshold is set to %g => ignore it", duration,
  88               smpi_cpu_threshold);
  89   }
  90 }
  91
  92 void smpi_bench_begin()
  93 {
  94   if (smpi_privatize_global_variables == SMPI_PRIVATIZE_MMAP) {
  95     smpi_switch_data_segment(smpi_process()->index());
  96   }
  97
  98   if (MC_is_active() || MC_record_replay_is_active())
  99     return;
 100
 101 #if HAVE_PAPI
 102   if (xbt_cfg_get_string("smpi/papi-events")[0] != '\0') {
 103     int event_set = smpi_process()->papi_event_set();
 104     // PAPI_start sets everything to 0! See man(3) PAPI_start
 105     if (PAPI_LOW_LEVEL_INITED == PAPI_is_initialized()) {
 106       if (PAPI_start(event_set) != PAPI_OK) {
 107         // TODO This needs some proper handling.
 108         XBT_CRITICAL("Could not start PAPI counters.\n");
 109         xbt_die("Error.");
 110       }
 111     }
 112   }
 113 #endif
 114   xbt_os_threadtimer_start(smpi_process()->timer());
 115 }
 116
 117 void smpi_bench_end()
 118 {
 119   if (MC_is_active() || MC_record_replay_is_active())
 120     return;
 121
 122   double speedup = 1;
 123   xbt_os_timer_t timer = smpi_process()->timer();
 124   xbt_os_threadtimer_stop(timer);
 125
 126 #if HAVE_PAPI
 127   /**
 128    * An MPI function has been called and now is the right time to update
 129    * our PAPI counters for this process.
 130    */
 131   if (xbt_cfg_get_string("smpi/papi-events")[0] != '\0') {
 132     papi_counter_t& counter_data        = smpi_process()->papi_counters();
 133     int event_set                       = smpi_process()->papi_event_set();
 134     std::vector<long long> event_values = std::vector<long long>(counter_data.size());
 135
 136     if (PAPI_stop(event_set, &event_values[0]) != PAPI_OK) { // Error
 137       XBT_CRITICAL("Could not stop PAPI counters.\n");
 138       xbt_die("Error.");
 139     } else {
 140       for (unsigned int i = 0; i < counter_data.size(); i++) {
 141         counter_data[i].second += event_values[i];
 142         // XBT_DEBUG("[%i] PAPI: Counter %s: Value is now %lli (got increment by %lli\n", smpi_process()->index(),
 143         // counter_data[i].first.c_str(), counter_data[i].second, event_values[i]);
 144       }
 145     }
 146   }
 147 #endif
 148
 149   if (smpi_process()->sampling()) {
 150     XBT_CRITICAL("Cannot do recursive benchmarks.");
 151     XBT_CRITICAL("Are you trying to make a call to MPI within a SMPI_SAMPLE_ block?");
 152     xbt_backtrace_display_current();
 153     xbt_die("Aborting.");
 154   }
 155
 156   if (xbt_cfg_get_string("smpi/comp-adjustment-file")[0] != '\0') { // Maybe we need to artificially speed up or slow
 157     // down our computation based on our statistical analysis.
 158
 159     smpi_trace_call_location_t* loc                            = smpi_process()->call_location();
 160     std::string key                                            = loc->get_composed_key();
 161     std::unordered_map<std::string, double>::const_iterator it = location2speedup.find(key);
 162     if (it != location2speedup.end()) {
 163       speedup = it->second;
 164     }
 165   }
 166
 167   // Simulate the benchmarked computation unless disabled via command-line argument
 168   if (xbt_cfg_get_boolean("smpi/simulate-computation")) {
 169     smpi_execute(xbt_os_timer_elapsed(timer)/speedup);
 170   }
 171
 172 #if HAVE_PAPI
 173   if (xbt_cfg_get_string("smpi/papi-events")[0] != '\0' && TRACE_smpi_is_enabled()) {
 174     char container_name[INSTR_DEFAULT_STR_SIZE];
 175     smpi_container(smpi_process()->index(), container_name, INSTR_DEFAULT_STR_SIZE);
 176     container_t container        = PJ_container_get(container_name);
 177     papi_counter_t& counter_data = smpi_process()->papi_counters();
 178
 179     for (auto& pair : counter_data) {
 180       new_pajeSetVariable(surf_get_clock(), container,
 181                           PJ_type_get(/* countername */ pair.first.c_str(), container->type), pair.second);
 182     }
 183   }
 184 #endif
 185
 186   smpi_total_benched_time += xbt_os_timer_elapsed(timer);
 187 }
 188
 189 /* Private sleep function used by smpi_sleep() and smpi_usleep() */
 190 static unsigned int private_sleep(double secs)
 191 {
 192   smpi_bench_end();
 193
 194   XBT_DEBUG("Sleep for: %lf secs", secs);
 195   int rank = MPI_COMM_WORLD->rank();
 196   instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
 197   extra->type=TRACING_SLEEPING;
 198   extra->sleep_duration=secs;
 199   TRACE_smpi_sleeping_in(rank, extra);
 200
 201   simcall_process_sleep(secs);
 202
 203   TRACE_smpi_sleeping_out(rank);
 204
 205   smpi_bench_begin();
 206   return 0;
 207 }
 208
 209 unsigned int smpi_sleep(unsigned int secs)
 210 {
 211   return private_sleep(static_cast<double>(secs));
 212 }
 213
 214 int smpi_usleep(useconds_t usecs)
 215 {
 216   return static_cast<int>(private_sleep(static_cast<double>(usecs) / 1000000.0));
 217 }
 218
 219 #if _POSIX_TIMERS > 0
 220 int smpi_nanosleep(const struct timespec *tp, struct timespec * t)
 221 {
 222   return static_cast<int>(private_sleep(static_cast<double>(tp->tv_sec + tp->tv_nsec / 1000000000.0)));
 223 }
 224 #endif
 225
 226 int smpi_gettimeofday(struct timeval *tv, void* tz)
 227 {
 228   smpi_bench_end();
 229   double now = SIMIX_get_clock();
 230   if (tv) {
 231     tv->tv_sec = static_cast<time_t>(now);
 232 #ifdef WIN32
 233     tv->tv_usec = static_cast<useconds_t>((now - tv->tv_sec) * 1e6);
 234 #else
 235     tv->tv_usec = static_cast<suseconds_t>((now - tv->tv_sec) * 1e6);
 236 #endif
 237   }
 238   smpi_bench_begin();
 239   return 0;
 240 }
 241
 242 #if _POSIX_TIMERS > 0
 243 int smpi_clock_gettime(clockid_t clk_id, struct timespec *tp)
 244 {
 245   //there is only one time in SMPI, so clk_id is ignored.
 246   smpi_bench_end();
 247   double now = SIMIX_get_clock();
 248   if (tp) {
 249     tp->tv_sec = static_cast<time_t>(now);
 250     tp->tv_nsec = static_cast<long int>((now - tp->tv_sec) * 1e9);
 251   }
 252   smpi_bench_begin();
 253   return 0;
 254 }
 255 #endif
 256
 257 extern double sg_surf_precision;
 258 unsigned long long smpi_rastro_resolution ()
 259 {
 260   smpi_bench_end();
 261   double resolution = (1/sg_surf_precision);
 262   smpi_bench_begin();
 263   return static_cast<unsigned long long>(resolution);
 264 }
 265
 266 unsigned long long smpi_rastro_timestamp ()
 267 {
 268   smpi_bench_end();
 269   double now = SIMIX_get_clock();
 270
 271   unsigned long long sec = static_cast<unsigned long long>(now);
 272   unsigned long long pre = (now - sec) * smpi_rastro_resolution();
 273   smpi_bench_begin();
 274   return static_cast<unsigned long long>(sec) * smpi_rastro_resolution() + pre;
 275 }
 276
 277 /* ****************************** Functions related to the SMPI_SAMPLE_ macros ************************************/
 278 typedef struct {
 279   double threshold; /* maximal stderr requested (if positive) */
 280   double relstderr; /* observed stderr so far */
 281   double mean;      /* mean of benched times, to be used if the block is disabled */
 282   double sum;       /* sum of benched times (to compute the mean and stderr) */
 283   double sum_pow2;  /* sum of the square of the benched times (to compute the stderr) */
 284   int iters;        /* amount of requested iterations */
 285   int count;        /* amount of iterations done so far */
 286   int benching;     /* 1: we are benchmarking; 0: we have enough data, no bench anymore */
 287 } local_data_t;
 288
 289 static char *sample_location(int global, const char *file, int line) {
 290   if (global) {
 291     return bprintf("%s:%d", file, line);
 292   } else {
 293     return bprintf("%s:%d:%d", file, line, smpi_process()->index());
 294   }
 295 }
 296
 297 static int sample_enough_benchs(local_data_t *data) {
 298   int res = data->count >= data->iters;
 299   if (data->threshold>0.0) {
 300     if (data->count <2)
 301       res = 0; // not enough data
 302     if (data->relstderr > data->threshold)
 303       res = 0; // stderr too high yet
 304   }
 305   XBT_DEBUG("%s (count:%d iter:%d stderr:%f thres:%f mean:%fs)",
 306       (res?"enough benchs":"need more data"), data->count, data->iters, data->relstderr, data->threshold, data->mean);
 307   return res;
 308 }
 309
 310 void smpi_sample_1(int global, const char *file, int line, int iters, double threshold)
 311 {
 312   char *loc = sample_location(global, file, line);
 313
 314   smpi_bench_end();     /* Take time from previous, unrelated computation into account */
 315   smpi_process()->set_sampling(1);
 316
 317   if (samples==nullptr)
 318     samples = xbt_dict_new_homogeneous(free);
 319
 320   local_data_t *data = static_cast<local_data_t *>(xbt_dict_get_or_null(samples, loc));
 321   if (data==nullptr) {
 322     xbt_assert(threshold>0 || iters>0,
 323         "You should provide either a positive amount of iterations to bench, or a positive maximal stderr (or both)");
 324     data = static_cast<local_data_t *>( xbt_new(local_data_t, 1));
 325     data->count = 0;
 326     data->sum = 0.0;
 327     data->sum_pow2 = 0.0;
 328     data->iters = iters;
 329     data->threshold = threshold;
 330     data->benching = 1; // If we have no data, we need at least one
 331     data->mean = 0;
 332     xbt_dict_set(samples, loc, data, nullptr);
 333     XBT_DEBUG("XXXXX First time ever on benched nest %s.",loc);
 334   } else {
 335     if (data->iters != iters || data->threshold != threshold) {
 336       XBT_ERROR("Asked to bench block %s with different settings %d, %f is not %d, %f. "
 337                 "How did you manage to give two numbers at the same line??",
 338                 loc, data->iters, data->threshold, iters, threshold);
 339       THROW_IMPOSSIBLE;
 340     }
 341
 342     // if we already have some data, check whether sample_2 should get one more bench or whether it should emulate
 343     // the computation instead
 344     data->benching = (sample_enough_benchs(data) == 0);
 345     XBT_DEBUG("XXXX Re-entering the benched nest %s. %s", loc,
 346               (data->benching ? "more benching needed" : "we have enough data, skip computes"));
 347   }
 348   xbt_free(loc);
 349 }
 350
 351 int smpi_sample_2(int global, const char *file, int line)
 352 {
 353   char *loc = sample_location(global, file, line);
 354   int res;
 355
 356   xbt_assert(samples, "Y U NO use SMPI_SAMPLE_* macros? Stop messing directly with smpi_sample_* functions!");
 357   local_data_t *data = static_cast<local_data_t *>(xbt_dict_get(samples, loc));
 358   XBT_DEBUG("sample2 %s",loc);
 359   xbt_free(loc);
 360
 361   if (data->benching==1) {
 362     // we need to run a new bench
 363     XBT_DEBUG("benchmarking: count:%d iter:%d stderr:%f thres:%f; mean:%f",
 364         data->count, data->iters, data->relstderr, data->threshold, data->mean);
 365     res = 1;
 366   } else {
 367     // Enough data, no more bench (either we got enough data from previous visits to this benched nest, or we just
 368     //ran one bench and need to bail out now that our job is done). Just sleep instead
 369     XBT_DEBUG("No benchmark (either no need, or just ran one): count >= iter (%d >= %d) or stderr<thres (%f<=%f)."
 370               " apply the %fs delay instead",
 371               data->count, data->iters, data->relstderr, data->threshold, data->mean);
 372     smpi_execute(data->mean);
 373     smpi_process()->set_sampling(0);
 374     res = 0; // prepare to capture future, unrelated computations
 375   }
 376   smpi_bench_begin();
 377   return res;
 378 }
 379
 380 void smpi_sample_3(int global, const char *file, int line)
 381 {
 382   char *loc = sample_location(global, file, line);
 383
 384   xbt_assert(samples, "Y U NO use SMPI_SAMPLE_* macros? Stop messing directly with smpi_sample_* functions!");
 385   local_data_t *data = static_cast<local_data_t *>(xbt_dict_get(samples, loc));
 386   XBT_DEBUG("sample3 %s",loc);
 387   xbt_free(loc);
 388
 389   if (data->benching==0)
 390     THROW_IMPOSSIBLE;
 391
 392   // ok, benchmarking this loop is over
 393   xbt_os_threadtimer_stop(smpi_process()->timer());
 394
 395   // update the stats
 396   data->count++;
 397   double sample = xbt_os_timer_elapsed(smpi_process()->timer());
 398   data->sum += sample;
 399   data->sum_pow2 += sample * sample;
 400   double n = static_cast<double>(data->count);
 401   data->mean = data->sum / n;
 402   data->relstderr = sqrt((data->sum_pow2 / n - data->mean * data->mean) / n) / data->mean;
 403   if (sample_enough_benchs(data)==0) {
 404     data->mean = sample; // Still in benching process; We want sample_2 to simulate the exact time of this loop
 405     // occurrence before leaving, not the mean over the history
 406   }
 407   XBT_DEBUG("Average mean after %d steps is %f, relative standard error is %f (sample was %f)", data->count,
 408       data->mean, data->relstderr, sample);
 409
 410   // That's enough for now, prevent sample_2 to run the same code over and over
 411   data->benching = 0;
 412 }
 413
 414 extern "C" { /** These functions will be called from the user code **/
 415   smpi_trace_call_location_t* smpi_trace_get_call_location() {
 416     return smpi_process()->call_location();
 417   }
 418
 419   void smpi_trace_set_call_location(const char* file, const int line) {
 420     smpi_trace_call_location_t* loc = smpi_process()->call_location();
 421
 422     loc->previous_filename   = loc->filename;
 423     loc->previous_linenumber = loc->linenumber;
 424     loc->filename            = file;
 425     loc->linenumber          = line;
 426   }
 427
 428   /**
 429    * Required for Fortran bindings
 430    */
 431   void smpi_trace_set_call_location_(const char* file, int* line) {
 432     smpi_trace_set_call_location(file, *line);
 433   }
 434
 435   /**
 436    * Required for Fortran if -fsecond-underscore is activated
 437    */
 438   void smpi_trace_set_call_location__(const char* file, int* line) {
 439     smpi_trace_set_call_location(file, *line);
 440   }
 441 }