Logo AND Algorithmique Numérique Distribuée

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