Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
Have smpi_bench.c see HAVE_MMAP flag
[simgrid.git] / src / smpi / smpi_bench.c
1 /* Copyright (c) 2007, 2009-2014. 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 "internal_config.h"
8 #include "private.h"
9 #include "xbt/dict.h"
10 #include "xbt/sysdep.h"
11 #include "xbt/ex.h"
12 #include "xbt/hash.h"
13 #include "surf/surf.h"
14 #include "simgrid/sg_config.h"
15
16 #ifndef WIN32
17 #include <sys/mman.h>
18 #endif
19 #include <sys/stat.h>
20 #include <sys/types.h>
21 #include <errno.h>
22 #include <fcntl.h>
23 #include <math.h> // sqrt
24 #include <unistd.h>
25 #include <string.h>
26 #include <stdio.h>
27
28 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(smpi_bench, smpi,
29                                 "Logging specific to SMPI (benchmarking)");
30
31 /* Shared allocations are handled through shared memory segments.
32  * Associated data and metadata are used as follows:
33  *
34  *                                                                    mmap #1
35  *    `allocs' dict                                                     ---- -.
36  *    ----------      shared_data_t               shared_metadata_t   / |  |  |
37  * .->| <name> | ---> -------------------- <--.   -----------------   | |  |  |
38  * |  ----------      | fd of <name>     |    |   | size of mmap  | --| |  |  |
39  * |                  | count (2)        |    |-- | data          |   \ |  |  |
40  * `----------------- | <name>           |    |   -----------------     ----  |
41  *                    --------------------    |   ^                           |
42  *                                            |   |                           |
43  *                                            |   |   `allocs_metadata' dict  |
44  *                                            |   |   ----------------------  |
45  *                                            |   `-- | <addr of mmap #1>  |<-'
46  *                                            |   .-- | <addr of mmap #2>  |<-.
47  *                                            |   |   ----------------------  |
48  *                                            |   |                           |
49  *                                            |   |                           |
50  *                                            |   |                           |
51  *                                            |   |                   mmap #2 |
52  *                                            |   v                     ---- -'
53  *                                            |   shared_metadata_t   / |  |
54  *                                            |   -----------------   | |  |
55  *                                            |   | size of mmap  | --| |  |
56  *                                            `-- | data          |   | |  |
57  *                                                -----------------   | |  |
58  *                                                                    \ |  |
59  *                                                                      ----
60  */
61
62 #define PTR_STRLEN (2 + 2 * sizeof(void*) + 1)
63
64 xbt_dict_t allocs = NULL;          /* Allocated on first use */
65 xbt_dict_t allocs_metadata = NULL; /* Allocated on first use */
66 xbt_dict_t samples = NULL;         /* Allocated on first use */
67 xbt_dict_t calls = NULL;           /* Allocated on first use */
68 __thread int smpi_current_rank = 0;      /* Updated after each MPI call */
69
70 double smpi_cpu_threshold;
71 double smpi_running_power;
72
73 int* fds;
74 void** mappings;
75 int loaded_page = -1;
76 char* start_data_exe = NULL;
77 int size_data_exe = 0;
78 int smpi_privatize_global_variables;
79
80 typedef struct {
81   int fd;
82   int count;
83   char* loc;
84 } shared_data_t;
85
86 typedef struct  {
87   size_t size;
88   shared_data_t* data;
89 } shared_metadata_t;
90
91 static size_t shm_size(int fd) {
92   struct stat st;
93
94   if(fstat(fd, &st) < 0) {
95     xbt_die("Could not stat fd %d: %s", fd, strerror(errno));
96   }
97   return (size_t)st.st_size;
98 }
99
100 #ifndef WIN32
101 static void* shm_map(int fd, size_t size, shared_data_t* data) {
102   void* mem;
103   char loc[PTR_STRLEN];
104   shared_metadata_t* meta;
105
106   if(size > shm_size(fd)) {
107     if(ftruncate(fd, (off_t)size) < 0) {
108       xbt_die("Could not truncate fd %d to %zu: %s", fd, size, strerror(errno));
109     }
110   }
111
112   mem = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
113   if(mem == MAP_FAILED) {
114     xbt_die("Could not map fd %d: %s", fd, strerror(errno));
115   }
116   if(!allocs_metadata) {
117     allocs_metadata = xbt_dict_new_homogeneous(xbt_free);
118   }
119   snprintf(loc, PTR_STRLEN, "%p", mem);
120   meta = xbt_new(shared_metadata_t, 1);
121   meta->size = size;
122   meta->data = data;
123   xbt_dict_set(allocs_metadata, loc, meta, NULL);
124   XBT_DEBUG("MMAP %zu to %p", size, mem);
125   return mem;
126 }
127 #endif
128
129 void smpi_bench_destroy(void)
130 {
131   xbt_dict_free(&allocs);
132   xbt_dict_free(&allocs_metadata);
133   xbt_dict_free(&samples);
134   xbt_dict_free(&calls);
135 }
136
137 XBT_PUBLIC(void) smpi_execute_flops_(double *flops);
138 void smpi_execute_flops_(double *flops)
139 {
140   smpi_execute_flops(*flops);
141 }
142
143 XBT_PUBLIC(void) smpi_execute_(double *duration);
144 void smpi_execute_(double *duration)
145 {
146   smpi_execute(*duration);
147 }
148
149 void smpi_execute_flops(double flops) {
150   smx_action_t action;
151   smx_host_t host;
152   host = SIMIX_host_self();
153   XBT_DEBUG("Handle real computation time: %f flops", flops);
154   action = simcall_host_execute("computation", host, flops, 1, 0, 0);
155 #ifdef HAVE_TRACING
156   simcall_set_category (action, TRACE_internal_smpi_get_category());
157 #endif
158   simcall_host_execution_wait(action);
159 }
160
161 void smpi_execute(double duration)
162 {
163   if (duration >= smpi_cpu_threshold) {
164     XBT_DEBUG("Sleep for %g to handle real computation time", duration);
165     double flops = duration * smpi_running_power;
166 #ifdef HAVE_TRACING
167     int rank = smpi_process_index();
168     instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
169     extra->type=TRACING_COMPUTING;
170     extra->comp_size=flops;
171     TRACE_smpi_computing_in(rank, extra);
172 #endif
173     smpi_execute_flops(flops);
174
175 #ifdef HAVE_TRACING
176     TRACE_smpi_computing_out(rank);
177 #endif
178
179   } else {
180     XBT_DEBUG("Real computation took %g while option smpi/cpu_threshold is set to %g => ignore it",
181               duration, smpi_cpu_threshold);
182   }
183 }
184
185 void switch_data_segment(int dest);
186
187 void smpi_bench_begin(void)
188 {
189   switch_data_segment(smpi_process_index());
190   xbt_os_threadtimer_start(smpi_process_timer());
191   smpi_current_rank = smpi_process_index();
192 }
193
194 void smpi_bench_end(void)
195 {
196   xbt_os_timer_t timer = smpi_process_timer();
197   xbt_os_threadtimer_stop(timer);
198 //  switch_data_segment(smpi_process_count());
199   if (smpi_process_get_sampling()) {
200     XBT_CRITICAL("Cannot do recursive benchmarks.");
201     XBT_CRITICAL("Are you trying to make a call to MPI within a SMPI_SAMPLE_ block?");
202     xbt_backtrace_display_current();
203     xbt_die("Aborting.");
204   }
205   smpi_execute(xbt_os_timer_elapsed(timer));
206 }
207
208 unsigned int smpi_sleep(unsigned int secs)
209 {
210   smx_action_t action;
211
212   smpi_bench_end();
213
214   double flops = (double) secs*simcall_host_get_speed(SIMIX_host_self());
215   XBT_DEBUG("Sleep for: %f flops", flops);
216   action = simcall_host_execute("computation", SIMIX_host_self(), flops, 1, 0, 0);
217   #ifdef HAVE_TRACING
218     simcall_set_category (action, TRACE_internal_smpi_get_category());
219   #endif
220   simcall_host_execution_wait(action);
221
222   smpi_bench_begin();
223   return secs;
224 }
225
226 int smpi_gettimeofday(struct timeval *tv)
227 {
228   double now;
229   smpi_bench_end();
230   now = SIMIX_get_clock();
231   if (tv) {
232     tv->tv_sec = (time_t)now;
233 #ifdef WIN32
234     tv->tv_usec = (useconds_t)((now - tv->tv_sec) * 1e6);
235 #else
236     tv->tv_usec = (suseconds_t)((now - tv->tv_sec) * 1e6);
237 #endif
238   }
239   smpi_bench_begin();
240   return 0;
241 }
242
243 extern double sg_maxmin_precision;
244 unsigned long long smpi_rastro_resolution (void)
245 {
246   smpi_bench_end();
247   double resolution = (1/sg_maxmin_precision);
248   smpi_bench_begin();
249   return (unsigned long long)resolution;
250 }
251
252 unsigned long long smpi_rastro_timestamp (void)
253 {
254   smpi_bench_end();
255   double now = SIMIX_get_clock();
256
257   unsigned long long sec = (unsigned long long)now;
258   unsigned long long pre = (now - sec) * smpi_rastro_resolution();
259   smpi_bench_begin();
260   return (unsigned long long)sec * smpi_rastro_resolution() + pre;
261 }
262
263 /* ****************************** Functions related to the SMPI_SAMPLE_ macros ************************************/
264 typedef struct {
265   double threshold; /* maximal stderr requested (if positive) */
266   double relstderr; /* observed stderr so far */
267   double mean;      /* mean of benched times, to be used if the block is disabled */
268   double sum;       /* sum of benched times (to compute the mean and stderr) */
269   double sum_pow2;  /* sum of the square of the benched times (to compute the stderr) */
270   int iters;        /* amount of requested iterations */
271   int count;        /* amount of iterations done so far */
272   int benching;     /* 1: we are benchmarking; 0: we have enough data, no bench anymore */
273 } local_data_t;
274
275 static char *sample_location(int global, const char *file, int line) {
276   if (global) {
277     return bprintf("%s:%d", file, line);
278   } else {
279     return bprintf("%s:%d:%d", file, line, smpi_process_index());
280   }
281 }
282 static int sample_enough_benchs(local_data_t *data) {
283   int res = data->count >= data->iters;
284   if (data->threshold>0.0) {
285     if (data->count <2)
286       res = 0; // not enough data
287     if (data->relstderr > data->threshold)
288       res = 0; // stderr too high yet
289   }
290   XBT_DEBUG("%s (count:%d iter:%d stderr:%f thres:%f mean:%fs)",
291       (res?"enough benchs":"need more data"),
292       data->count, data->iters, data->relstderr, data->threshold, data->mean);
293   return res;
294 }
295
296 void smpi_sample_1(int global, const char *file, int line, int iters, double threshold)
297 {
298   char *loc = sample_location(global, file, line);
299   local_data_t *data;
300
301   smpi_bench_end();     /* Take time from previous, unrelated computation into account */
302   smpi_process_set_sampling(1);
303
304   if (!samples)
305     samples = xbt_dict_new_homogeneous(free);
306
307   data = xbt_dict_get_or_null(samples, loc);
308   if (!data) {
309     xbt_assert(threshold>0 || iters>0,
310         "You should provide either a positive amount of iterations to bench, or a positive maximal stderr (or both)");
311     data = (local_data_t *) xbt_new(local_data_t, 1);
312     data->count = 0;
313     data->sum = 0.0;
314     data->sum_pow2 = 0.0;
315     data->iters = iters;
316     data->threshold = threshold;
317     data->benching = 1; // If we have no data, we need at least one
318     data->mean = 0;
319     xbt_dict_set(samples, loc, data, NULL);
320     XBT_DEBUG("XXXXX First time ever on benched nest %s.",loc);
321   } else {
322     if (data->iters != iters || data->threshold != threshold) {
323       XBT_ERROR("Asked to bench block %s with different settings %d, %f is not %d, %f. How did you manage to give two numbers at the same line??",
324           loc, data->iters, data->threshold, iters,threshold);
325       THROW_IMPOSSIBLE;
326     }
327
328     // if we already have some data, check whether sample_2 should get one more bench or whether it should emulate the computation instead
329     data->benching = !sample_enough_benchs(data);
330     XBT_DEBUG("XXXX Re-entering the benched nest %s. %s",loc, (data->benching?"more benching needed":"we have enough data, skip computes"));
331   }
332   xbt_free(loc);
333 }
334
335 int smpi_sample_2(int global, const char *file, int line)
336 {
337   char *loc = sample_location(global, file, line);
338   local_data_t *data;
339   int res;
340
341   xbt_assert(samples, "Y U NO use SMPI_SAMPLE_* macros? Stop messing directly with smpi_sample_* functions!");
342   data = xbt_dict_get(samples, loc);
343   XBT_DEBUG("sample2 %s",loc);
344   xbt_free(loc);
345
346   if (data->benching==1) {
347     // we need to run a new bench
348     XBT_DEBUG("benchmarking: count:%d iter:%d stderr:%f thres:%f; mean:%f",
349         data->count, data->iters, data->relstderr, data->threshold, data->mean);
350     res = 1;
351   } else {
352     // Enough data, no more bench (either we got enough data from previous visits to this benched nest, or we just ran one bench and need to bail out now that our job is done).
353     // Just sleep instead
354     XBT_DEBUG("No benchmark (either no need, or just ran one): count >= iter (%d >= %d) or stderr<thres (%f<=%f). apply the %fs delay instead",
355         data->count, data->iters, data->relstderr, data->threshold, data->mean);
356     smpi_execute(data->mean);
357     smpi_process_set_sampling(0);
358     res = 0; // prepare to capture future, unrelated computations
359   }
360   smpi_bench_begin();
361   return res;
362 }
363
364
365 void smpi_sample_3(int global, const char *file, int line)
366 {
367   char *loc = sample_location(global, file, line);
368   local_data_t *data;
369
370   xbt_assert(samples, "Y U NO use SMPI_SAMPLE_* macros? Stop messing directly with smpi_sample_* functions!");
371   data = xbt_dict_get(samples, loc);
372   XBT_DEBUG("sample3 %s",loc);
373   xbt_free(loc);
374
375   if (data->benching==0) {
376     THROW_IMPOSSIBLE;
377   }
378
379   // ok, benchmarking this loop is over
380   xbt_os_threadtimer_stop(smpi_process_timer());
381
382   // update the stats
383   double sample, n;
384   data->count++;
385   sample = xbt_os_timer_elapsed(smpi_process_timer());
386   data->sum += sample;
387   data->sum_pow2 += sample * sample;
388   n = (double)data->count;
389   data->mean = data->sum / n;
390   data->relstderr = sqrt((data->sum_pow2 / n - data->mean * data->mean) / n) / data->mean;
391   if (!sample_enough_benchs(data)) {
392     data->mean = sample; // Still in benching process; We want sample_2 to simulate the exact time of this loop occurrence before leaving, not the mean over the history
393   }
394   XBT_DEBUG("Average mean after %d steps is %f, relative standard error is %f (sample was %f)", data->count,
395       data->mean, data->relstderr, sample);
396
397   // That's enough for now, prevent sample_2 to run the same code over and over
398   data->benching = 0;
399 }
400
401 #ifndef WIN32
402 static void smpi_shared_alloc_free(void *p)
403 {
404   shared_data_t *data = p;
405   xbt_free(data->loc);
406   xbt_free(data);
407 }
408
409 static char *smpi_shared_alloc_hash(char *loc)
410 {
411   char hash[42];
412   char s[7];
413   unsigned val;
414   int i, j;
415
416   xbt_sha(loc, hash);
417   hash[41] = '\0';
418   s[6] = '\0';
419   loc = xbt_realloc(loc, 30);
420   loc[0] = '/';
421   for (i = 0; i < 40; i += 6) { /* base64 encode */
422     memcpy(s, hash + i, 6);
423     val = strtoul(s, NULL, 16);
424     for (j = 0; j < 4; j++) {
425       unsigned char x = (val >> (18 - 3 * j)) & 0x3f;
426       loc[1 + 4 * i / 6 + j] =
427         "ABCDEFGHIJKLMNOPQRSTUVZXYZabcdefghijklmnopqrstuvzxyz0123456789-_"[x];
428     }
429   }
430   loc[29] = '\0';
431   return loc;
432 }
433
434 void *smpi_shared_malloc(size_t size, const char *file, int line)
435 {
436   void* mem;
437   if (sg_cfg_get_boolean("smpi/use_shared_malloc")){
438     char *loc = bprintf("%zu_%s_%d", (size_t)getpid(), file, line);
439     int fd;
440     shared_data_t *data;
441     loc = smpi_shared_alloc_hash(loc); /* hash loc, in order to have something
442                                         * not too long */
443     if (!allocs) {
444       allocs = xbt_dict_new_homogeneous(smpi_shared_alloc_free);
445     }
446     data = xbt_dict_get_or_null(allocs, loc);
447     if (!data) {
448       fd = shm_open(loc, O_RDWR | O_CREAT | O_EXCL,
449                     S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
450       if (fd < 0) {
451         switch(errno) {
452           case EEXIST:
453             xbt_die("Please cleanup /dev/shm/%s", loc);
454           default:
455             xbt_die("An unhandled error occured while opening %s. shm_open: %s", loc, strerror(errno));
456         }
457       }
458       data = xbt_new(shared_data_t, 1);
459       data->fd = fd;
460       data->count = 1;
461       data->loc = loc;
462       mem = shm_map(fd, size, data);
463       if (shm_unlink(loc) < 0) {
464         XBT_WARN("Could not early unlink %s. shm_unlink: %s", loc, strerror(errno));
465       }
466       xbt_dict_set(allocs, loc, data, NULL);
467       XBT_DEBUG("Mapping %s at %p through %d", loc, mem, fd);
468     } else {
469       xbt_free(loc);
470       mem = shm_map(data->fd, size, data);
471       data->count++;
472     }
473     XBT_DEBUG("Shared malloc %zu in %p (metadata at %p)", size, mem, data);
474   } else {
475     mem = xbt_malloc(size);
476     XBT_DEBUG("Classic malloc %zu in %p", size, mem);
477   }
478
479   return mem;
480 }
481 void smpi_shared_free(void *ptr)
482 {
483   char loc[PTR_STRLEN];
484   shared_metadata_t* meta;
485   shared_data_t* data;
486   if (sg_cfg_get_boolean("smpi/use_shared_malloc")){
487   
488     if (!allocs) {
489       XBT_WARN("Cannot free: nothing was allocated");
490       return;
491     }
492     if(!allocs_metadata) {
493       XBT_WARN("Cannot free: no metadata was allocated");
494     }
495     snprintf(loc, PTR_STRLEN, "%p", ptr);
496     meta = (shared_metadata_t*)xbt_dict_get_or_null(allocs_metadata, loc);
497     if (!meta) {
498       XBT_WARN("Cannot free: %p was not shared-allocated by SMPI", ptr);
499       return;
500     }
501     data = meta->data;
502     if(!data) {
503       XBT_WARN("Cannot free: something is broken in the metadata link");
504       return;
505     }
506     if(munmap(ptr, meta->size) < 0) {
507       XBT_WARN("Unmapping of fd %d failed: %s", data->fd, strerror(errno));
508     }
509     data->count--;
510     XBT_DEBUG("Shared free - no removal - of %p, count = %d", ptr, data->count);
511     if (data->count <= 0) {
512       close(data->fd);
513       xbt_dict_remove(allocs, data->loc);
514       XBT_DEBUG("Shared free - with removal - of %p", ptr);
515     }
516   }else{
517     XBT_DEBUG("Classic free of %p", ptr);
518     xbt_free(ptr);
519   }
520 }
521 #endif
522
523 int smpi_shared_known_call(const char* func, const char* input)
524 {
525   char* loc = bprintf("%s:%s", func, input);
526   xbt_ex_t ex;
527   int known = 0;
528
529   if (!calls) {
530     calls = xbt_dict_new_homogeneous(NULL);
531   }
532   TRY {
533     xbt_dict_get(calls, loc); /* Succeed or throw */
534     known = 1;
535   }
536   TRY_CLEANUP {
537     xbt_free(loc);
538   }
539   CATCH(ex) {
540     if (ex.category != not_found_error)
541       RETHROW;
542     xbt_ex_free(ex);
543   }
544   return known;
545 }
546
547 void* smpi_shared_get_call(const char* func, const char* input) {
548    char* loc = bprintf("%s:%s", func, input);
549    void* data;
550
551    if(!calls) {
552       calls = xbt_dict_new_homogeneous(NULL);
553    }
554    data = xbt_dict_get(calls, loc);
555    free(loc);
556    return data;
557 }
558
559 void* smpi_shared_set_call(const char* func, const char* input, void* data) {
560    char* loc = bprintf("%s:%s", func, input);
561
562    if(!calls) {
563       calls = xbt_dict_new_homogeneous(NULL);
564    }
565    xbt_dict_set(calls, loc, data, NULL);
566    free(loc);
567    return data;
568 }
569
570
571
572
573 #ifndef WIN32
574 #define TOPAGE(addr) (void *)(((unsigned long)(addr) / xbt_pagesize) * xbt_pagesize)
575
576
577 /*
578  * - read the executable data+bss section addresses and sizes
579  * - for each process create a copy of these sections with mmap
580  * - store them in a dynar
581  *
582  */
583
584
585
586 void switch_data_segment(int dest){
587
588   if(size_data_exe == 0)//no need to switch
589     return;
590
591   if (loaded_page==dest)//no need to switch either
592     return;
593 #ifdef HAVE_MMAP
594   int current= fds[dest];
595   XBT_VERB("Switching data frame to the one of process %d", dest);
596   void* tmp = mmap (TOPAGE(start_data_exe), size_data_exe, PROT_READ | PROT_WRITE, MAP_FIXED | MAP_SHARED, current, 0);
597   msync(TOPAGE(start_data_exe), size_data_exe, MS_SYNC | MS_INVALIDATE );
598   if (tmp != TOPAGE(start_data_exe))
599     xbt_die("Couldn't map the new region");
600   loaded_page=dest;
601 #endif
602 }
603
604 void smpi_get_executable_global_size(){
605   int size_bss_binary=0;
606   int size_data_binary=0;
607   FILE *fp;
608   char *line = NULL;            /* Temporal storage for each line that is readed */
609   ssize_t read;                 /* Number of bytes readed */
610   size_t n = 0;                 /* Amount of bytes to read by xbt_getline */
611
612   char *lfields[7];
613   int i, found = 0;
614
615   char *command = bprintf("objdump --section-headers %s", xbt_binary_name);
616
617   fp = popen(command, "r");
618
619   if(fp == NULL){
620     perror("popen failed");
621     xbt_abort();
622   }
623
624   while ((read = xbt_getline(&line, &n, fp)) != -1 && found != 2) {
625
626     if(n == 0)
627       continue;
628
629     /* Wipeout the new line character */
630     line[read - 1] = '\0';
631
632     lfields[0] = strtok(line, " ");
633
634     if(lfields[0] == NULL)
635       continue;
636
637     if(strcmp(lfields[0], "Sections:") == 0
638         || strcmp(lfields[0], "Idx") == 0
639         || strncmp(lfields[0], xbt_binary_name, strlen(xbt_binary_name)) == 0)
640       continue;
641
642     for (i = 1; i < 7 && lfields[i - 1] != NULL; i++) {
643       lfields[i] = strtok(NULL, " ");
644     }
645
646     /*
647      * we are looking for these fields
648     23 .data         02625a20  00000000006013e0  00000000006013e0  000013e0  2**5
649                      CONTENTS, ALLOC, LOAD, DATA
650     24 .bss          02625a40  0000000002c26e00  0000000002c26e00  02626e00  2**5
651                      ALLOC
652     */
653
654     if(i>=6){
655       if(strcmp(lfields[1], ".data") == 0){
656         size_data_binary = strtoul(lfields[2], NULL, 16);
657         start_data_exe = (char*) strtoul(lfields[4], NULL, 16);
658         found++;
659       }else if(strcmp(lfields[1], ".bss") == 0){
660         //the beginning of bss is not exactly the end of data if not aligned, grow bss reported size accordingly
661         //TODO : check if this is OK, as some segments may be inserted between them.. 
662         size_bss_binary = ((char*) strtoul(lfields[4], NULL, 16) - (start_data_exe + size_data_binary))
663                           + strtoul(lfields[2], NULL, 16);
664         found++;
665        }
666
667     }
668
669   }
670
671   size_data_exe =(unsigned long)start_data_exe - (unsigned long)TOPAGE(start_data_exe)+ size_data_binary+size_bss_binary;
672   xbt_free(command);
673   xbt_free(line);
674   pclose(fp);
675
676 }
677
678 void smpi_initialize_global_memory_segments(){
679
680 #ifndef HAVE_MMAP
681   smpi_privatize_global_variables=0;
682   return;
683 #else
684
685   unsigned int i = 0;
686   smpi_get_executable_global_size();
687
688   XBT_DEBUG ("bss+data segment found : size %d starting at %p",size_data_exe, start_data_exe );
689
690   if(size_data_exe == 0){//no need to switch
691     smpi_privatize_global_variables=0;
692     return;
693   }
694
695   fds= (int*)xbt_malloc((smpi_process_count())*sizeof(int));
696   mappings= (void**)xbt_malloc((smpi_process_count())*sizeof(void*));
697
698
699   for (i=0; i< SIMIX_process_count(); i++){
700       //create SIMIX_process_count() mappings of this size with the same data inside
701       void *address = NULL, *tmp = NULL;
702       char path[] = "/dev/shm/my-buffer-XXXXXX";
703       int status;
704       int file_descriptor= mkstemp (path);
705       if (file_descriptor < 0)
706         xbt_die("Impossible to create temporary file for memory mapping");
707       status = unlink (path);
708       if (status)
709         xbt_die("Impossible to unlink temporary file for memory mapping");
710
711       status = ftruncate(file_descriptor, size_data_exe);
712       if(status)
713         xbt_die("Impossible to set the size of the temporary file for memory mapping");
714
715       /* Ask for a free region */
716       address = mmap (NULL, size_data_exe, PROT_NONE, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
717
718       if (address == MAP_FAILED)
719         xbt_die("Couldn't find a free region for memory mapping");
720
721       tmp = mmap (address, size_data_exe, PROT_READ | PROT_WRITE, MAP_FIXED | MAP_SHARED, file_descriptor, 0);
722
723       if (tmp != address)
724         xbt_die("Couldn't obtain the right address");
725       //initialize the values
726       memcpy(address,TOPAGE(start_data_exe),size_data_exe);
727
728       //store the address of the mapping for further switches
729       fds[i]=file_descriptor;
730       mappings[i]= address;
731   }
732
733 #endif
734
735 }
736
737 void smpi_destroy_global_memory_segments(){
738   if(size_data_exe == 0)//no need to switch
739     return;
740 #ifdef HAVE_MMAP
741   int i;
742   for (i=0; i< smpi_process_count(); i++){
743     if(munmap(mappings[i],size_data_exe) < 0) {
744       XBT_WARN("Unmapping of fd %d failed: %s", fds[i], strerror(errno));
745     }
746     close(fds[i]);
747   }
748   xbt_free(mappings);
749   xbt_free(fds);
750
751 #endif
752
753 }
754
755
756 #endif