src/smpi/smpi_bench.cpp

   1 /* Copyright (c) 2007, 2009-2015. The SimGrid Team.
   2  * All rights reserved.                                                     */
   3
   4 /* This program is free software; you can redistribute it and/or modify it
   5  * under the terms of the license (GNU LGPL) which comes with this package. */
   6
   7 #include <cstring>
   8
   9 #include <unordered_map>
  10 #include <utility>
  11
  12 #include "src/internal_config.h"
  13 #include "private.h"
  14 #include "private.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 #ifndef WIN32
  24 #include <sys/mman.h>
  25 #endif
  26 #include <sys/stat.h>
  27 #include <sys/types.h>
  28 #include <errno.h>
  29 #include <fcntl.h>
  30 #include <math.h> // sqrt
  31 #include <unistd.h>
  32 #include <string.h>
  33 #include <stdio.h>
  34
  35 #ifndef MAP_ANONYMOUS
  36 #define MAP_ANONYMOUS MAP_ANON
  37 #endif
  38
  39 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(smpi_bench, smpi, "Logging specific to SMPI (benchmarking)");
  40
  41 /* Shared allocations are handled through shared memory segments.
  42  * Associated data and metadata are used as follows:
  43  *
  44  *                                                                    mmap #1
  45  *    `allocs' dict                                                     ---- -.
  46  *    ----------      shared_data_t               shared_metadata_t   / |  |  |
  47  * .->| <name> | ---> -------------------- <--.   -----------------   | |  |  |
  48  * |  ----------      | fd of <name>     |    |   | size of mmap  | --| |  |  |
  49  * |                  | count (2)        |    |-- | data          |   \ |  |  |
  50  * `----------------- | <name>           |    |   -----------------     ----  |
  51  *                    --------------------    |   ^                           |
  52  *                                            |   |                           |
  53  *                                            |   |   `allocs_metadata' dict  |
  54  *                                            |   |   ----------------------  |
  55  *                                            |   `-- | <addr of mmap #1>  |<-'
  56  *                                            |   .-- | <addr of mmap #2>  |<-.
  57  *                                            |   |   ----------------------  |
  58  *                                            |   |                           |
  59  *                                            |   |                           |
  60  *                                            |   |                           |
  61  *                                            |   |                   mmap #2 |
  62  *                                            |   v                     ---- -'
  63  *                                            |   shared_metadata_t   / |  |
  64  *                                            |   -----------------   | |  |
  65  *                                            |   | size of mmap  | --| |  |
  66  *                                            `-- | data          |   | |  |
  67  *                                                -----------------   | |  |
  68  *                                                                    \ |  |
  69  *                                                                      ----
  70  */
  71
  72 #define PTR_STRLEN (2 + 2 * sizeof(void*) + 1)
  73
  74 xbt_dict_t samples = nullptr;         /* Allocated on first use */
  75 xbt_dict_t calls = nullptr;           /* Allocated on first use */
  76
  77 double smpi_cpu_threshold;
  78 double smpi_running_power;
  79
  80 int smpi_loaded_page = -1;
  81 char* smpi_start_data_exe = nullptr;
  82 int smpi_size_data_exe = 0;
  83 bool smpi_privatize_global_variables;
  84 double smpi_total_benched_time = 0;
  85 smpi_privatisation_region_t smpi_privatisation_regions;
  86
  87 namespace {
  88
  89 /** Some location in the source code
  90  *
  91  *  This information is used by SMPI_SHARED_MALLOC to allocate  some shared memory for all simulated processes.
  92  */
  93 class smpi_source_location {
  94 public:
  95   smpi_source_location(const char* filename, int line)
  96     : filename(filename), filename_length(strlen(filename)), line(line) {}
  97
  98   /** Pointer to a static string containing the file name */
  99   const char* filename = nullptr;
 100   int filename_length = 0;
 101   int line = 0;
 102
 103   bool operator==(smpi_source_location const& that) const
 104   {
 105     return filename_length == that.filename_length
 106       && line == that.line
 107       && std::memcmp(filename, that.filename, filename_length) == 0;
 108   }
 109   bool operator!=(smpi_source_location const& that) const
 110   {
 111     return !(*this == that);
 112   }
 113 };
 114
 115 }
 116
 117 namespace std {
 118
 119 template<>
 120 class hash<smpi_source_location> {
 121 public:
 122   typedef smpi_source_location argument_type;
 123   typedef std::size_t result_type;
 124   result_type operator()(smpi_source_location const& loc) const
 125   {
 126     return xbt_str_hash_ext(loc.filename, loc.filename_length)
 127       ^ xbt_str_hash_ext((const char*) &loc.line, sizeof(loc.line));
 128   }
 129 };
 130
 131 }
 132
 133 namespace {
 134
 135 typedef struct {
 136   int fd = -1;
 137   int count = 0;
 138 } shared_data_t;
 139
 140 std::unordered_map<smpi_source_location, shared_data_t> allocs;
 141 typedef std::unordered_map<smpi_source_location, shared_data_t>::value_type shared_data_key_type;
 142
 143 typedef struct  {
 144   size_t size;
 145   shared_data_key_type* data;
 146 } shared_metadata_t;
 147
 148 std::unordered_map<void*, shared_metadata_t> allocs_metadata;
 149
 150 }
 151
 152 static size_t shm_size(int fd) {
 153   struct stat st;
 154
 155   if(fstat(fd, &st) < 0) {
 156     xbt_die("Could not stat fd %d: %s", fd, strerror(errno));
 157   }
 158   return static_cast<size_t>(st.st_size);
 159 }
 160
 161 #ifndef WIN32
 162 static void* shm_map(int fd, size_t size, shared_data_key_type* data) {
 163   void* mem;
 164   char loc[PTR_STRLEN];
 165   shared_metadata_t meta;
 166
 167   if(size > shm_size(fd) && (ftruncate(fd, static_cast<off_t>(size)) < 0)) {
 168       xbt_die("Could not truncate fd %d to %zu: %s", fd, size, strerror(errno));
 169   }
 170
 171   mem = mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
 172   if(mem == MAP_FAILED) {
 173     xbt_die("Could not map fd %d: %s", fd, strerror(errno));
 174   }
 175   snprintf(loc, PTR_STRLEN, "%p", mem);
 176   meta.size = size;
 177   meta.data = data;
 178   allocs_metadata[mem] = meta;
 179   XBT_DEBUG("MMAP %zu to %p", size, mem);
 180   return mem;
 181 }
 182 #endif
 183
 184 void smpi_bench_destroy(void)
 185 {
 186   allocs.clear();
 187   allocs_metadata.clear();
 188   xbt_dict_free(&samples);
 189   xbt_dict_free(&calls);
 190 }
 191
 192 extern "C" XBT_PUBLIC(void) smpi_execute_flops_(double *flops);
 193 void smpi_execute_flops_(double *flops)
 194 {
 195   smpi_execute_flops(*flops);
 196 }
 197
 198 extern "C" XBT_PUBLIC(void) smpi_execute_(double *duration);
 199 void smpi_execute_(double *duration)
 200 {
 201   smpi_execute(*duration);
 202 }
 203
 204 void smpi_execute_flops(double flops) {
 205   smx_synchro_t action;
 206   XBT_DEBUG("Handle real computation time: %f flops", flops);
 207   action = simcall_execution_start("computation", flops, 1, 0, 0);
 208   simcall_set_category (action, TRACE_internal_smpi_get_category());
 209   simcall_execution_wait(action);
 210   smpi_switch_data_segment(smpi_process_index());
 211 }
 212
 213 void smpi_execute(double duration)
 214 {
 215   if (duration >= smpi_cpu_threshold) {
 216     XBT_DEBUG("Sleep for %g to handle real computation time", duration);
 217     double flops = duration * smpi_running_power;
 218     int rank = smpi_process_index();
 219     instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
 220     extra->type=TRACING_COMPUTING;
 221     extra->comp_size=flops;
 222     TRACE_smpi_computing_in(rank, extra);
 223     smpi_execute_flops(flops);
 224
 225     TRACE_smpi_computing_out(rank);
 226
 227   } else {
 228     XBT_DEBUG("Real computation took %g while option smpi/cpu_threshold is set to %g => ignore it",
 229               duration, smpi_cpu_threshold);
 230   }
 231 }
 232
 233 void smpi_switch_data_segment(int dest);
 234
 235 void smpi_bench_begin(void)
 236 {
 237   if (smpi_privatize_global_variables) {
 238     smpi_switch_data_segment(smpi_process_index());
 239   }
 240
 241   if (MC_is_active() || MC_record_replay_is_active())
 242     return;
 243
 244   xbt_os_threadtimer_start(smpi_process_timer());
 245 }
 246
 247 void smpi_bench_end(void)
 248 {
 249
 250   if (MC_is_active() || MC_record_replay_is_active())
 251     return;
 252
 253   double speedup = 1;
 254   xbt_os_timer_t timer = smpi_process_timer();
 255   xbt_os_threadtimer_stop(timer);
 256   if (smpi_process_get_sampling()) {
 257     XBT_CRITICAL("Cannot do recursive benchmarks.");
 258     XBT_CRITICAL("Are you trying to make a call to MPI within a SMPI_SAMPLE_ block?");
 259     xbt_backtrace_display_current();
 260     xbt_die("Aborting.");
 261   }
 262
 263   if (xbt_cfg_get_string("smpi/comp-adjustment-file")[0] != '\0') { // Maybe we need to artificially speed up or slow
 264                                                          // down our computation based on our statistical analysis.
 265
 266     smpi_trace_call_location_t* loc                            = smpi_process_get_call_location();
 267     std::string key                                            = loc->get_composed_key();
 268     std::unordered_map<std::string, double>::const_iterator it = location2speedup.find(key);
 269     if (it != location2speedup.end()) {
 270       speedup = it->second;
 271     }
 272   }
 273
 274   // Simulate the benchmarked computation unless disabled via command-line argument
 275   if (xbt_cfg_get_boolean("smpi/simulate-computation")) {
 276     smpi_execute(xbt_os_timer_elapsed(timer)/speedup);
 277   }
 278
 279   smpi_total_benched_time += xbt_os_timer_elapsed(timer);
 280 }
 281
 282 /* Private sleep function used by smpi_sleep() and smpi_usleep() */
 283 static unsigned int private_sleep(double secs)
 284 {
 285   smpi_bench_end();
 286
 287   XBT_DEBUG("Sleep for: %lf secs", secs);
 288   int rank = smpi_comm_rank(MPI_COMM_WORLD);
 289   instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
 290   extra->type=TRACING_SLEEPING;
 291   extra->sleep_duration=secs;
 292   TRACE_smpi_sleeping_in(rank, extra);
 293
 294   simcall_process_sleep(secs);
 295
 296   TRACE_smpi_sleeping_out(rank);
 297
 298   smpi_bench_begin();
 299   return 0;
 300 }
 301
 302 unsigned int smpi_sleep(unsigned int secs)
 303 {
 304   return private_sleep(static_cast<double>(secs));
 305 }
 306
 307 int smpi_usleep(useconds_t usecs)
 308 {
 309   return static_cast<int>(private_sleep(static_cast<double>(usecs) / 1000000.0));
 310 }
 311
 312 int smpi_gettimeofday(struct timeval *tv, void* tz)
 313 {
 314   double now;
 315   smpi_bench_end();
 316   now = SIMIX_get_clock();
 317   if (tv) {
 318     tv->tv_sec = static_cast<time_t>(now);
 319 #ifdef WIN32
 320     tv->tv_usec = static_cast<useconds_t>((now - tv->tv_sec) * 1e6);
 321 #else
 322     tv->tv_usec = static_cast<suseconds_t>((now - tv->tv_sec) * 1e6);
 323 #endif
 324   }
 325   smpi_bench_begin();
 326   return 0;
 327 }
 328
 329 extern double sg_surf_precision;
 330 unsigned long long smpi_rastro_resolution (void)
 331 {
 332   smpi_bench_end();
 333   double resolution = (1/sg_surf_precision);
 334   smpi_bench_begin();
 335   return static_cast<unsigned long long>(resolution);
 336 }
 337
 338 unsigned long long smpi_rastro_timestamp (void)
 339 {
 340   smpi_bench_end();
 341   double now = SIMIX_get_clock();
 342
 343   unsigned long long sec = (unsigned long long)now;
 344   unsigned long long pre = (now - sec) * smpi_rastro_resolution();
 345   smpi_bench_begin();
 346   return static_cast<unsigned long long>(sec) * smpi_rastro_resolution() + pre;
 347 }
 348
 349 /* ****************************** Functions related to the SMPI_SAMPLE_ macros ************************************/
 350 typedef struct {
 351   double threshold; /* maximal stderr requested (if positive) */
 352   double relstderr; /* observed stderr so far */
 353   double mean;      /* mean of benched times, to be used if the block is disabled */
 354   double sum;       /* sum of benched times (to compute the mean and stderr) */
 355   double sum_pow2;  /* sum of the square of the benched times (to compute the stderr) */
 356   int iters;        /* amount of requested iterations */
 357   int count;        /* amount of iterations done so far */
 358   int benching;     /* 1: we are benchmarking; 0: we have enough data, no bench anymore */
 359 } local_data_t;
 360
 361 static char *sample_location(int global, const char *file, int line) {
 362   if (global) {
 363     return bprintf("%s:%d", file, line);
 364   } else {
 365     return bprintf("%s:%d:%d", file, line, smpi_process_index());
 366   }
 367 }
 368
 369 static int sample_enough_benchs(local_data_t *data) {
 370   int res = data->count >= data->iters;
 371   if (data->threshold>0.0) {
 372     if (data->count <2)
 373       res = 0; // not enough data
 374     if (data->relstderr > data->threshold)
 375       res = 0; // stderr too high yet
 376   }
 377   XBT_DEBUG("%s (count:%d iter:%d stderr:%f thres:%f mean:%fs)",
 378       (res?"enough benchs":"need more data"), data->count, data->iters, data->relstderr, data->threshold, data->mean);
 379   return res;
 380 }
 381
 382 void smpi_sample_1(int global, const char *file, int line, int iters, double threshold)
 383 {
 384   char *loc = sample_location(global, file, line);
 385   local_data_t *data;
 386
 387   smpi_bench_end();     /* Take time from previous, unrelated computation into account */
 388   smpi_process_set_sampling(1);
 389
 390   if (samples==nullptr)
 391     samples = xbt_dict_new_homogeneous(free);
 392
 393   data = static_cast<local_data_t *>(xbt_dict_get_or_null(samples, loc));
 394   if (data==nullptr) {
 395     xbt_assert(threshold>0 || iters>0,
 396         "You should provide either a positive amount of iterations to bench, or a positive maximal stderr (or both)");
 397     data = static_cast<local_data_t *>( xbt_new(local_data_t, 1));
 398     data->count = 0;
 399     data->sum = 0.0;
 400     data->sum_pow2 = 0.0;
 401     data->iters = iters;
 402     data->threshold = threshold;
 403     data->benching = 1; // If we have no data, we need at least one
 404     data->mean = 0;
 405     xbt_dict_set(samples, loc, data, nullptr);
 406     XBT_DEBUG("XXXXX First time ever on benched nest %s.",loc);
 407   } else {
 408     if (data->iters != iters || data->threshold != threshold) {
 409       XBT_ERROR("Asked to bench block %s with different settings %d, %f is not %d, %f. "
 410                 "How did you manage to give two numbers at the same line??",
 411                 loc, data->iters, data->threshold, iters,threshold);
 412       THROW_IMPOSSIBLE;
 413     }
 414
 415     // if we already have some data, check whether sample_2 should get one more bench or whether it should emulate
 416     // the computation instead
 417     data->benching = (sample_enough_benchs(data) == 0);
 418     XBT_DEBUG("XXXX Re-entering the benched nest %s. %s",loc,
 419              (data->benching?"more benching needed":"we have enough data, skip computes"));
 420   }
 421   xbt_free(loc);
 422 }
 423
 424 int smpi_sample_2(int global, const char *file, int line)
 425 {
 426   char *loc = sample_location(global, file, line);
 427   local_data_t *data;
 428   int res;
 429
 430   xbt_assert(samples, "Y U NO use SMPI_SAMPLE_* macros? Stop messing directly with smpi_sample_* functions!");
 431   data = static_cast<local_data_t *>(xbt_dict_get(samples, loc));
 432   XBT_DEBUG("sample2 %s",loc);
 433   xbt_free(loc);
 434
 435   if (data->benching==1) {
 436     // we need to run a new bench
 437     XBT_DEBUG("benchmarking: count:%d iter:%d stderr:%f thres:%f; mean:%f",
 438         data->count, data->iters, data->relstderr, data->threshold, data->mean);
 439     res = 1;
 440   } else {
 441     // Enough data, no more bench (either we got enough data from previous visits to this benched nest, or we just
 442     //ran one bench and need to bail out now that our job is done). Just sleep instead
 443     XBT_DEBUG("No benchmark (either no need, or just ran one): count >= iter (%d >= %d) or stderr<thres (%f<=%f)."
 444               " apply the %fs delay instead", data->count, data->iters, data->relstderr, data->threshold, data->mean);
 445     smpi_execute(data->mean);
 446     smpi_process_set_sampling(0);
 447     res = 0; // prepare to capture future, unrelated computations
 448   }
 449   smpi_bench_begin();
 450   return res;
 451 }
 452
 453 void smpi_sample_3(int global, const char *file, int line)
 454 {
 455   char *loc = sample_location(global, file, line);
 456   local_data_t *data;
 457
 458   xbt_assert(samples, "Y U NO use SMPI_SAMPLE_* macros? Stop messing directly with smpi_sample_* functions!");
 459   data = static_cast<local_data_t *>(xbt_dict_get(samples, loc));
 460   XBT_DEBUG("sample3 %s",loc);
 461   xbt_free(loc);
 462
 463   if (data->benching==0) {
 464     THROW_IMPOSSIBLE;
 465   }
 466
 467   // ok, benchmarking this loop is over
 468   xbt_os_threadtimer_stop(smpi_process_timer());
 469
 470   // update the stats
 471   double sample, n;
 472   data->count++;
 473   sample = xbt_os_timer_elapsed(smpi_process_timer());
 474   data->sum += sample;
 475   data->sum_pow2 += sample * sample;
 476   n = static_cast<double>(data->count);
 477   data->mean = data->sum / n;
 478   data->relstderr = sqrt((data->sum_pow2 / n - data->mean * data->mean) / n) / data->mean;
 479   if (sample_enough_benchs(data)==0) {
 480     data->mean = sample; // Still in benching process; We want sample_2 to simulate the exact time of this loop
 481                          // occurrence before leaving, not the mean over the history
 482   }
 483   XBT_DEBUG("Average mean after %d steps is %f, relative standard error is %f (sample was %f)", data->count,
 484       data->mean, data->relstderr, sample);
 485
 486   // That's enough for now, prevent sample_2 to run the same code over and over
 487   data->benching = 0;
 488 }
 489
 490 #ifndef WIN32
 491
 492 void *smpi_shared_malloc(size_t size, const char *file, int line)
 493 {
 494   void* mem;
 495   if (xbt_cfg_get_boolean("smpi/use-shared-malloc")){
 496     int fd;
 497     smpi_source_location loc(file, line);
 498     auto res = allocs.insert(std::make_pair(loc, shared_data_t()));
 499     auto data = res.first;
 500     if (res.second) {
 501       // The insertion did not take place.
 502       // Generate a shared memory name from the address of the shared_data:
 503       char shmname[32]; // cannot be longer than PSHMNAMLEN = 31 on Mac OS X (shm_open raises ENAMETOOLONG otherwise)
 504       snprintf(shmname, 31, "/shmalloc%p", &*data);
 505       fd = shm_open(shmname, O_RDWR | O_CREAT | O_EXCL, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
 506       if (fd < 0) {
 507         if(errno==EEXIST)
 508           xbt_die("Please cleanup /dev/shm/%s", shmname);
 509         else
 510           xbt_die("An unhandled error occurred while opening %s. shm_open: %s", shmname, strerror(errno));
 511       }
 512       data->second.fd = fd;
 513       data->second.count = 1;
 514       mem = shm_map(fd, size, &*data);
 515       if (shm_unlink(shmname) < 0) {
 516         XBT_WARN("Could not early unlink %s. shm_unlink: %s", shmname, strerror(errno));
 517       }
 518       XBT_DEBUG("Mapping %s at %p through %d", shmname, mem, fd);
 519     } else {
 520       mem = shm_map(data->second.fd, size, &*data);
 521       data->second.count++;
 522     }
 523     XBT_DEBUG("Shared malloc %zu in %p (metadata at %p)", size, mem, &*data);
 524   } else {
 525     mem = xbt_malloc(size);
 526     XBT_DEBUG("Classic malloc %zu in %p", size, mem);
 527   }
 528
 529   return mem;
 530 }
 531
 532 void smpi_shared_free(void *ptr)
 533 {
 534   char loc[PTR_STRLEN];
 535
 536   if (xbt_cfg_get_boolean("smpi/use-shared-malloc")){
 537     snprintf(loc, PTR_STRLEN, "%p", ptr);
 538     auto meta = allocs_metadata.find(ptr);
 539     if (meta == allocs_metadata.end()) {
 540       XBT_WARN("Cannot free: %p was not shared-allocated by SMPI", ptr);
 541       return;
 542     }
 543     shared_data_t* data = &meta->second.data->second;
 544     if (munmap(ptr, meta->second.size) < 0) {
 545       XBT_WARN("Unmapping of fd %d failed: %s", data->fd, strerror(errno));
 546     }
 547     data->count--;
 548     XBT_DEBUG("Shared free - no removal - of %p, count = %d", ptr, data->count);
 549     if (data->count <= 0) {
 550       close(data->fd);
 551       allocs.erase(allocs.find(meta->second.data->first));
 552       XBT_DEBUG("Shared free - with removal - of %p", ptr);
 553     }
 554   }else{
 555     XBT_DEBUG("Classic free of %p", ptr);
 556     xbt_free(ptr);
 557   }
 558 }
 559 #endif
 560
 561 int smpi_shared_known_call(const char* func, const char* input)
 562 {
 563   char* loc = bprintf("%s:%s", func, input);
 564   int known = 0;
 565
 566   if (calls==nullptr) {
 567     calls = xbt_dict_new_homogeneous(nullptr);
 568   }
 569   try {
 570     xbt_dict_get(calls, loc); /* Succeed or throw */
 571     known = 1;
 572     xbt_free(loc);
 573   }
 574   catch (xbt_ex& ex) {
 575     xbt_free(loc);
 576     if (ex.category != not_found_error)
 577       throw;
 578   }
 579   catch(...) {
 580     xbt_free(loc);
 581     throw;
 582   }
 583   return known;
 584 }
 585
 586 void* smpi_shared_get_call(const char* func, const char* input) {
 587    char* loc = bprintf("%s:%s", func, input);
 588    void* data;
 589
 590    if(calls==nullptr) {
 591       calls = xbt_dict_new_homogeneous(nullptr);
 592    }
 593    data = xbt_dict_get(calls, loc);
 594    xbt_free(loc);
 595    return data;
 596 }
 597
 598 void* smpi_shared_set_call(const char* func, const char* input, void* data) {
 599    char* loc = bprintf("%s:%s", func, input);
 600
 601    if(calls==0) {
 602       calls = xbt_dict_new_homogeneous(nullptr);
 603    }
 604    xbt_dict_set(calls, loc, data, nullptr);
 605    xbt_free(loc);
 606    return data;
 607 }
 608
 609
 610 /** Map a given SMPI privatization segment (make a SMPI process active) */
 611 void smpi_switch_data_segment(int dest){
 612   if (smpi_loaded_page==dest)//no need to switch either
 613    return;
 614
 615   // So the job:
 616   smpi_really_switch_data_segment(dest);
 617 }
 618
 619 /** Map a given SMPI privatization segment (make a SMPI process active)  even if SMPI thinks it is already active
 620  *
 621  *  When doing a state restoration, the state of the restored variables  might not be consistent with the state of the
 622  *  virtual memory. In this case, we to change the data segment.
 623  */
 624 void smpi_really_switch_data_segment(int dest) {
 625   if(smpi_size_data_exe == 0)//no need to switch
 626     return;
 627
 628 #if HAVE_PRIVATIZATION
 629   if(smpi_loaded_page==-1){//initial switch, do the copy from the real page here
 630     for (int i=0; i< smpi_process_count(); i++){
 631       memcpy(smpi_privatisation_regions[i].address, TOPAGE(smpi_start_data_exe), smpi_size_data_exe);
 632     }
 633   }
 634
 635   // FIXME, cross-process support (mmap across process when necessary)
 636   int current = smpi_privatisation_regions[dest].file_descriptor;
 637   XBT_DEBUG("Switching data frame to the one of process %d", dest);
 638   void* tmp = mmap (TOPAGE(smpi_start_data_exe), smpi_size_data_exe,
 639     PROT_READ | PROT_WRITE, MAP_FIXED | MAP_SHARED, current, 0);
 640   if (tmp != TOPAGE(smpi_start_data_exe))
 641     xbt_die("Couldn't map the new region");
 642   smpi_loaded_page = dest;
 643 #endif
 644 }
 645
 646 int smpi_is_privatisation_file(char* file)
 647 {
 648   return strncmp("/dev/shm/my-buffer-", file, std::strlen("/dev/shm/my-buffer-")) == 0;
 649 }
 650
 651 void smpi_initialize_global_memory_segments(){
 652
 653 #if !HAVE_PRIVATIZATION
 654   smpi_privatize_global_variables=false;
 655   xbt_die("You are trying to use privatization on a system that does not support it. Don't.");
 656   return;
 657 #else
 658
 659   smpi_get_executable_global_size();
 660
 661   XBT_DEBUG ("bss+data segment found : size %d starting at %p", smpi_size_data_exe, smpi_start_data_exe );
 662
 663   if (smpi_size_data_exe == 0){//no need to switch
 664     smpi_privatize_global_variables=false;
 665     return;
 666   }
 667
 668   smpi_privatisation_regions =
 669     static_cast<smpi_privatisation_region_t>( xbt_malloc(smpi_process_count() * sizeof(struct s_smpi_privatisation_region)));
 670
 671   for (int i=0; i< smpi_process_count(); i++){
 672       //create SIMIX_process_count() mappings of this size with the same data inside
 673       void *address = nullptr;
 674       char path[] = "/dev/shm/my-buffer-XXXXXX";
 675       int status;
 676
 677       int file_descriptor= mkstemp (path);
 678       if (file_descriptor < 0) {
 679         if (errno==EMFILE) {
 680           xbt_die("Impossible to create temporary file for memory mapping: %s\n\
 681 The open() system call failed with the EMFILE error code (too many files). \n\n\
 682 This means that you reached the system limits concerning the amount of files per process. \
 683 This is not a surprise if you are trying to virtualize many processes on top of SMPI. \
 684 Don't panic -- you should simply increase your system limits and try again. \n\n\
 685 First, check what your limits are:\n\
 686   cat /proc/sys/fs/file-max # Gives you the system-wide limit\n\
 687   ulimit -Hn                # Gives you the per process hard limit\n\
 688   ulimit -Sn                # Gives you the per process soft limit\n\
 689   cat /proc/self/limits     # Displays any per-process limitation (including the one given above)\n\n\
 690 If one of these values is less than the amount of MPI processes that you try to run, then you got the explanation of this error. \
 691 Ask the Internet about tutorials on how to increase the files limit such as: https://rtcamp.com/tutorials/linux/increase-open-files-limit/",
 692              strerror(errno));
 693         }
 694         xbt_die("Impossible to create temporary file for memory mapping: %s",
 695             strerror(errno));
 696       }
 697
 698       status = unlink (path);
 699       if (status)
 700         xbt_die("Impossible to unlink temporary file for memory mapping");
 701
 702       status = ftruncate(file_descriptor, smpi_size_data_exe);
 703       if(status)
 704         xbt_die("Impossible to set the size of the temporary file for memory mapping");
 705
 706       /* Ask for a free region */
 707       address = mmap (nullptr, smpi_size_data_exe, PROT_READ | PROT_WRITE, MAP_SHARED, file_descriptor, 0);
 708       if (address == MAP_FAILED)
 709         xbt_die("Couldn't find a free region for memory mapping");
 710
 711       //initialize the values
 712       memcpy(address, TOPAGE(smpi_start_data_exe), smpi_size_data_exe);
 713
 714       //store the address of the mapping for further switches
 715       smpi_privatisation_regions[i].file_descriptor = file_descriptor;
 716       smpi_privatisation_regions[i].address = address;
 717   }
 718 #endif
 719 }
 720
 721 void smpi_destroy_global_memory_segments(){
 722   if (smpi_size_data_exe == 0)//no need to switch
 723     return;
 724 #if HAVE_PRIVATIZATION
 725   int i;
 726   for (i=0; i< smpi_process_count(); i++){
 727     if(munmap(smpi_privatisation_regions[i].address, smpi_size_data_exe) < 0) {
 728       XBT_WARN("Unmapping of fd %d failed: %s", smpi_privatisation_regions[i].file_descriptor, strerror(errno));
 729     }
 730     close(smpi_privatisation_regions[i].file_descriptor);
 731   }
 732   xbt_free(smpi_privatisation_regions);
 733 #endif
 734 }
 735
 736 extern "C" { /** These functions will be called from the user code **/
 737   smpi_trace_call_location_t* smpi_trace_get_call_location() {
 738     return smpi_process_get_call_location();
 739   }
 740
 741   void smpi_trace_set_call_location(const char* file, const int line) {
 742     smpi_trace_call_location_t* loc = smpi_process_get_call_location();
 743
 744     loc->previous_filename   = loc->filename;
 745     loc->previous_linenumber = loc->linenumber;
 746     loc->filename            = file;
 747     loc->linenumber          = line;
 748   }
 749
 750   /**
 751    * Required for Fortran bindings
 752    */
 753   void smpi_trace_set_call_location_(const char* file, int* line) {
 754     smpi_trace_set_call_location(file, *line);
 755   }
 756
 757   /**
 758    * Required for Fortran if -fsecond-underscore is activated
 759    */
 760   void smpi_trace_set_call_location__(const char* file, int* line) {
 761     smpi_trace_set_call_location(file, *line);
 762   }
 763 }