+ // ok, benchmarking this loop is over
+ xbt_os_threadtimer_stop(smpi_process_timer());
+
+ // update the stats
+ double sample, n;
+ data->count++;
+ sample = xbt_os_timer_elapsed(smpi_process_timer());
+ data->sum += sample;
+ data->sum_pow2 += sample * sample;
+ n = (double)data->count;
+ data->mean = data->sum / n;
+ data->relstderr = sqrt((data->sum_pow2 / n - data->mean * data->mean) / n) / data->mean;
+ if (!sample_enough_benchs(data)) {
+ 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
+ }
+ XBT_DEBUG("Average mean after %d steps is %f, relative standard error is %f (sample was %f)", data->count,
+ data->mean, data->relstderr, sample);
+
+ // That's enough for now, prevent sample_2 to run the same code over and over
+ data->benching = 0;
+}
+
+#ifndef WIN32
+static void smpi_shared_alloc_free(void *p)
+{
+ shared_data_t *data = p;
+ xbt_free(data->loc);
+ xbt_free(data);
+}
+
+static char *smpi_shared_alloc_hash(char *loc)
+{
+ char hash[42];
+ char s[7];
+ unsigned val;
+ int i, j;
+
+ xbt_sha(loc, hash);
+ hash[41] = '\0';
+ s[6] = '\0';
+ loc = xbt_realloc(loc, 30);
+ loc[0] = '/';
+ for (i = 0; i < 40; i += 6) { /* base64 encode */
+ memcpy(s, hash + i, 6);
+ val = strtoul(s, NULL, 16);
+ for (j = 0; j < 4; j++) {
+ unsigned char x = (val >> (18 - 3 * j)) & 0x3f;
+ loc[1 + 4 * i / 6 + j] =
+ "ABCDEFGHIJKLMNOPQRSTUVZXYZabcdefghijklmnopqrstuvzxyz0123456789-_"[x];
+ }
+ }
+ loc[29] = '\0';
+ return loc;
+}
+
+void *smpi_shared_malloc(size_t size, const char *file, int line)
+{
+ void* mem;
+ if (sg_cfg_get_boolean("smpi/use_shared_malloc")){
+ char *loc = bprintf("%zu_%s_%d", (size_t)getpid(), file, line);
+ int fd;
+ shared_data_t *data;
+ loc = smpi_shared_alloc_hash(loc); /* hash loc, in order to have something
+ * not too long */
+ if (!allocs) {
+ allocs = xbt_dict_new_homogeneous(smpi_shared_alloc_free);
+ }
+ data = xbt_dict_get_or_null(allocs, loc);
+ if (!data) {
+ fd = shm_open(loc, O_RDWR | O_CREAT | O_EXCL,
+ S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
+ if (fd < 0) {
+ switch(errno) {
+ case EEXIST:
+ xbt_die("Please cleanup /dev/shm/%s", loc);
+ default:
+ xbt_die("An unhandled error occured while opening %s. shm_open: %s", loc, strerror(errno));
+ }
+ }
+ data = xbt_new(shared_data_t, 1);
+ data->fd = fd;
+ data->count = 1;
+ data->loc = loc;
+ mem = shm_map(fd, size, data);
+ if (shm_unlink(loc) < 0) {
+ XBT_WARN("Could not early unlink %s. shm_unlink: %s", loc, strerror(errno));
+ }
+ xbt_dict_set(allocs, loc, data, NULL);
+ XBT_DEBUG("Mapping %s at %p through %d", loc, mem, fd);
+ } else {
+ xbt_free(loc);
+ mem = shm_map(data->fd, size, data);
+ data->count++;
+ }
+ XBT_DEBUG("Shared malloc %zu in %p (metadata at %p)", size, mem, data);
+ } else {
+ mem = xbt_malloc(size);
+ XBT_DEBUG("Classic malloc %zu in %p", size, mem);
+ }
+
+ return mem;
+}
+void smpi_shared_free(void *ptr)
+{
+ char loc[PTR_STRLEN];
+ shared_metadata_t* meta;
+ shared_data_t* data;
+ if (sg_cfg_get_boolean("smpi/use_shared_malloc")){
+
+ if (!allocs) {
+ XBT_WARN("Cannot free: nothing was allocated");
+ return;
+ }
+ if(!allocs_metadata) {
+ XBT_WARN("Cannot free: no metadata was allocated");
+ }
+ snprintf(loc, PTR_STRLEN, "%p", ptr);
+ meta = (shared_metadata_t*)xbt_dict_get_or_null(allocs_metadata, loc);
+ if (!meta) {
+ XBT_WARN("Cannot free: %p was not shared-allocated by SMPI", ptr);
+ return;
+ }
+ data = meta->data;
+ if(!data) {
+ XBT_WARN("Cannot free: something is broken in the metadata link");
+ return;
+ }
+ if(munmap(ptr, meta->size) < 0) {
+ XBT_WARN("Unmapping of fd %d failed: %s", data->fd, strerror(errno));
+ }
+ data->count--;
+ XBT_DEBUG("Shared free - no removal - of %p, count = %d", ptr, data->count);
+ if (data->count <= 0) {
+ close(data->fd);
+ xbt_dict_remove(allocs, data->loc);
+ XBT_DEBUG("Shared free - with removal - of %p", ptr);
+ }
+ }else{
+ XBT_DEBUG("Classic free of %p", ptr);
+ xbt_free(ptr);
+ }
+}
+#endif
+
+int smpi_shared_known_call(const char* func, const char* input)
+{
+ char* loc = bprintf("%s:%s", func, input);
+ xbt_ex_t ex;
+ int known = 0;
+
+ if (!calls) {
+ calls = xbt_dict_new_homogeneous(NULL);
+ }
+ TRY {
+ xbt_dict_get(calls, loc); /* Succeed or throw */
+ known = 1;
+ }
+ TRY_CLEANUP {
+ xbt_free(loc);
+ }
+ CATCH(ex) {
+ if (ex.category != not_found_error)
+ RETHROW;
+ xbt_ex_free(ex);
+ }
+ return known;
+}
+
+void* smpi_shared_get_call(const char* func, const char* input) {
+ char* loc = bprintf("%s:%s", func, input);
+ void* data;
+
+ if(!calls) {
+ calls = xbt_dict_new_homogeneous(NULL);
+ }
+ data = xbt_dict_get(calls, loc);
+ free(loc);
+ return data;
+}
+
+void* smpi_shared_set_call(const char* func, const char* input, void* data) {
+ char* loc = bprintf("%s:%s", func, input);
+
+ if(!calls) {
+ calls = xbt_dict_new_homogeneous(NULL);
+ }
+ xbt_dict_set(calls, loc, data, NULL);
+ free(loc);
+ return data;
+}
+
+
+
+
+#define TOPAGE(addr) (void *)(((unsigned long)(addr) / xbt_pagesize) * xbt_pagesize)
+
+
+/*
+ * - read the executable data+bss section addresses and sizes
+ * - for each process create a copy of these sections with mmap
+ * - store them in a dynar
+ *
+ */
+
+
+
+void smpi_switch_data_segment(int dest){
+
+ if(size_data_exe == 0)//no need to switch
+ return;
+
+ if (smpi_loaded_page==dest)//no need to switch either
+ return;
+
+#ifdef HAVE_MMAP
+ int i;
+ if(smpi_loaded_page==-1){//initial switch, do the copy from the real page here
+ for (i=0; i< SIMIX_process_count(); i++){
+ memcpy(smpi_privatisation_regions[i].address,TOPAGE(start_data_exe),size_data_exe);
+ }
+ }
+ int current = smpi_privatisation_regions[dest].file_descriptor;
+ XBT_VERB("Switching data frame to the one of process %d", dest);
+ void* tmp = mmap (TOPAGE(start_data_exe), size_data_exe, PROT_READ | PROT_WRITE, MAP_FIXED | MAP_SHARED, current, 0);
+ if (tmp != TOPAGE(start_data_exe))
+ xbt_die("Couldn't map the new region");
+ smpi_loaded_page=dest;
+#endif
+}
+
+void smpi_get_executable_global_size(){
+ int size_bss_binary=0;
+ int size_data_binary=0;
+ FILE *fp;
+ char *line = NULL; /* Temporal storage for each line that is readed */
+ ssize_t read; /* Number of bytes readed */
+ size_t n = 0; /* Amount of bytes to read by xbt_getline */
+
+ char *lfields[7];
+ int i, found = 0;
+
+ char *command = bprintf("objdump --section-headers %s", xbt_binary_name);
+
+ fp = popen(command, "r");
+
+ if(fp == NULL){
+ perror("popen failed");
+ xbt_abort();
+ }
+
+ while ((read = xbt_getline(&line, &n, fp)) != -1 && found != 2) {
+
+ if(n == 0)
+ continue;
+
+ /* Wipeout the new line character */
+ line[read - 1] = '\0';
+
+ lfields[0] = strtok(line, " ");
+
+ if(lfields[0] == NULL)
+ continue;
+
+ if(strcmp(lfields[0], "Sections:") == 0
+ || strcmp(lfields[0], "Idx") == 0
+ || strncmp(lfields[0], xbt_binary_name, strlen(xbt_binary_name)) == 0)
+ continue;
+
+ for (i = 1; i < 7 && lfields[i - 1] != NULL; i++) {
+ lfields[i] = strtok(NULL, " ");
+ }
+
+ /*
+ * we are looking for these fields
+ 23 .data 02625a20 00000000006013e0 00000000006013e0 000013e0 2**5
+ CONTENTS, ALLOC, LOAD, DATA
+ 24 .bss 02625a40 0000000002c26e00 0000000002c26e00 02626e00 2**5
+ ALLOC
+ */
+
+ if(i>=6){
+ if(strcmp(lfields[1], ".data") == 0){
+ size_data_binary = strtoul(lfields[2], NULL, 16);
+ start_data_exe = (char*) strtoul(lfields[4], NULL, 16);
+ found++;
+ }else if(strcmp(lfields[1], ".bss") == 0){
+ //the beginning of bss is not exactly the end of data if not aligned, grow bss reported size accordingly
+ //TODO : check if this is OK, as some segments may be inserted between them..
+ size_bss_binary = ((char*) strtoul(lfields[4], NULL, 16) - (start_data_exe + size_data_binary))
+ + strtoul(lfields[2], NULL, 16);
+ found++;
+ }
+
+ }
+
+ }
+
+ size_data_exe =(unsigned long)start_data_exe - (unsigned long)TOPAGE(start_data_exe)+ size_data_binary+size_bss_binary;
+ xbt_free(command);
+ xbt_free(line);
+ pclose(fp);
+
+}
+
+void smpi_initialize_global_memory_segments(){
+
+#ifndef HAVE_MMAP
+ smpi_privatize_global_variables=0;
+ return;
+#else
+
+ unsigned int i = 0;
+ smpi_get_executable_global_size();
+
+ XBT_DEBUG ("bss+data segment found : size %d starting at %p",size_data_exe, start_data_exe );
+
+ if(size_data_exe == 0){//no need to switch
+ smpi_privatize_global_variables=0;
+ return;
+ }
+
+ smpi_privatisation_regions = (smpi_privatisation_region_t) malloc(
+ smpi_process_count() * sizeof(struct s_smpi_privatisation_region));
+
+ for (i=0; i< SIMIX_process_count(); i++){
+ //create SIMIX_process_count() mappings of this size with the same data inside
+ void *address = NULL;
+ char path[] = "/dev/shm/my-buffer-XXXXXX";
+ int status;
+
+ int file_descriptor= mkstemp (path);
+ if (file_descriptor < 0)
+ xbt_die("Impossible to create temporary file for memory mapping");
+
+ status = unlink (path);
+ if (status)
+ xbt_die("Impossible to unlink temporary file for memory mapping");
+
+ status = ftruncate(file_descriptor, size_data_exe);
+ if(status)
+ xbt_die("Impossible to set the size of the temporary file for memory mapping");
+
+ /* Ask for a free region */
+ address = mmap (NULL, size_data_exe, PROT_READ | PROT_WRITE, MAP_SHARED, file_descriptor, 0);
+ if (address == MAP_FAILED)
+ xbt_die("Couldn't find a free region for memory mapping");
+
+ //initialize the values
+ memcpy(address,TOPAGE(start_data_exe),size_data_exe);
+
+ //store the address of the mapping for further switches
+ smpi_privatisation_regions[i].file_descriptor = file_descriptor;
+ smpi_privatisation_regions[i].address = address;
+ }
+
+#endif
+
+}