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