X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/ed511a15702f5a82f740888d43348bc1c7e07205..838f47a13991d9f04fc4682b790688147b569132:/src/smpi/smpi_bench.cpp diff --git a/src/smpi/smpi_bench.cpp b/src/smpi/smpi_bench.cpp index 31dce5b38f..194208744d 100644 --- a/src/smpi/smpi_bench.cpp +++ b/src/smpi/smpi_bench.cpp @@ -1,194 +1,40 @@ -/* Copyright (c) 2007, 2009-2015. The SimGrid Team. - * All rights reserved. */ +/* Copyright (c) 2007, 2009-2017. The SimGrid Team. All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ -#include - -#include -#include - #include "src/internal_config.h" #include "private.h" #include "private.hpp" -#include "xbt/dict.h" -#include "xbt/sysdep.h" -#include "xbt/ex.h" -#include "surf/surf.h" -#include "simgrid/sg_config.h" #include "simgrid/modelchecker.h" #include "src/mc/mc_replay.h" +#include "src/smpi/smpi_process.hpp" +#include "src/smpi/smpi_comm.hpp" #ifndef WIN32 #include #endif -#include -#include -#include -#include #include // sqrt -#include -#include -#include -#ifndef MAP_ANONYMOUS -#define MAP_ANONYMOUS MAP_ANON +#if HAVE_PAPI +#include #endif XBT_LOG_NEW_DEFAULT_SUBCATEGORY(smpi_bench, smpi, "Logging specific to SMPI (benchmarking)"); -/* Shared allocations are handled through shared memory segments. - * Associated data and metadata are used as follows: - * - * mmap #1 - * `allocs' dict ---- -. - * ---------- shared_data_t shared_metadata_t / | | | - * .->| | ---> -------------------- <--. ----------------- | | | | - * | ---------- | fd of | | | size of mmap | --| | | | - * | | count (2) | |-- | data | \ | | | - * `----------------- | | | ----------------- ---- | - * -------------------- | ^ | - * | | | - * | | `allocs_metadata' dict | - * | | ---------------------- | - * | `-- | |<-' - * | .-- | |<-. - * | | ---------------------- | - * | | | - * | | | - * | | | - * | | mmap #2 | - * | v ---- -' - * | shared_metadata_t / | | - * | ----------------- | | | - * | | size of mmap | --| | | - * `-- | data | | | | - * ----------------- | | | - * \ | | - * ---- - */ - -#define PTR_STRLEN (2 + 2 * sizeof(void*) + 1) - -xbt_dict_t samples = NULL; /* Allocated on first use */ -xbt_dict_t calls = NULL; /* Allocated on first use */ - -double smpi_cpu_threshold; -double smpi_running_power; - -int smpi_loaded_page = -1; -char* smpi_start_data_exe = NULL; -int smpi_size_data_exe = 0; -int smpi_privatize_global_variables; -double smpi_total_benched_time = 0; -smpi_privatisation_region_t smpi_privatisation_regions; - -namespace { - -/** Some location in the source code - * - * This information is used by SMPI_SHARED_MALLOC to allocate some shared memory for all simulated processes. - */ -class smpi_source_location { -public: - smpi_source_location(const char* filename, int line) - : filename(filename), filename_length(strlen(filename)), line(line) {} - - /** Pointer to a static string containing the file name */ - const char* filename = nullptr; - int filename_length = 0; - int line = 0; - - bool operator==(smpi_source_location const& that) const - { - return filename_length == that.filename_length - && line == that.line - && std::memcmp(filename, that.filename, filename_length) == 0; - } - bool operator!=(smpi_source_location const& that) const - { - return !(*this == that); - } -}; -} - -namespace std { - -template<> -class hash { -public: - typedef smpi_source_location argument_type; - typedef std::size_t result_type; - result_type operator()(smpi_source_location const& loc) const - { - return xbt_str_hash_ext(loc.filename, loc.filename_length) - ^ xbt_str_hash_ext((const char*) &loc.line, sizeof(loc.line)); - } -}; +xbt_dict_t samples = nullptr; /* Allocated on first use */ -} - -namespace { - -typedef struct { - int fd = -1; - int count = 0; -} shared_data_t; - -std::unordered_map allocs; -typedef std::unordered_map::value_type shared_data_key_type; - -typedef struct { - size_t size; - shared_data_key_type* data; -} shared_metadata_t; - -std::unordered_map allocs_metadata; - -} +double smpi_cpu_threshold = -1; +double smpi_host_speed; -static size_t shm_size(int fd) { - struct stat st; - - if(fstat(fd, &st) < 0) { - xbt_die("Could not stat fd %d: %s", fd, strerror(errno)); - } - return (size_t)st.st_size; -} - -#ifndef WIN32 -static void* shm_map(int fd, size_t size, shared_data_key_type* data) { - void* mem; - char loc[PTR_STRLEN]; - shared_metadata_t meta; - - if(size > shm_size(fd)) { - if(ftruncate(fd, (off_t)size) < 0) { - xbt_die("Could not truncate fd %d to %zu: %s", fd, size, strerror(errno)); - } - } - - mem = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); - if(mem == MAP_FAILED) { - xbt_die("Could not map fd %d: %s", fd, strerror(errno)); - } - snprintf(loc, PTR_STRLEN, "%p", mem); - meta.size = size; - meta.data = data; - allocs_metadata[mem] = meta; - XBT_DEBUG("MMAP %zu to %p", size, mem); - return mem; -} -#endif +shared_malloc_type smpi_cfg_shared_malloc = shmalloc_global; +double smpi_total_benched_time = 0; +smpi_privatisation_region_t smpi_privatisation_regions; -void smpi_bench_destroy(void) +void smpi_bench_destroy() { - allocs.clear(); - allocs_metadata.clear(); xbt_dict_free(&samples); - xbt_dict_free(&calls); } extern "C" XBT_PUBLIC(void) smpi_execute_flops_(double *flops); @@ -204,59 +50,99 @@ void smpi_execute_(double *duration) } void smpi_execute_flops(double flops) { - smx_synchro_t action; XBT_DEBUG("Handle real computation time: %f flops", flops); - action = simcall_execution_start("computation", flops, 1, 0, 0); + smx_activity_t action = simcall_execution_start("computation", flops, 1, 0); simcall_set_category (action, TRACE_internal_smpi_get_category()); simcall_execution_wait(action); - smpi_switch_data_segment(smpi_process_index()); + smpi_switch_data_segment(smpi_process()->index()); } void smpi_execute(double duration) { if (duration >= smpi_cpu_threshold) { XBT_DEBUG("Sleep for %g to handle real computation time", duration); - double flops = duration * smpi_running_power; - int rank = smpi_process_index(); + double flops = duration * smpi_host_speed; + int rank = smpi_process()->index(); instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1); extra->type=TRACING_COMPUTING; extra->comp_size=flops; TRACE_smpi_computing_in(rank, extra); + smpi_execute_flops(flops); TRACE_smpi_computing_out(rank); } else { - XBT_DEBUG("Real computation took %g while option smpi/cpu_threshold is set to %g => ignore it", - duration, smpi_cpu_threshold); + XBT_DEBUG("Real computation took %g while option smpi/cpu_threshold is set to %g => ignore it", duration, + smpi_cpu_threshold); } } -void smpi_switch_data_segment(int dest); +void smpi_execute_public(double duration) +{ + smpi_bench_end(); + smpi_execute(duration); + smpi_bench_begin(); +} -void smpi_bench_begin(void) +void smpi_bench_begin() { - if (smpi_privatize_global_variables) { - smpi_switch_data_segment(smpi_process_index()); + if (smpi_privatize_global_variables == SMPI_PRIVATIZE_MMAP) { + smpi_switch_data_segment(smpi_process()->index()); } if (MC_is_active() || MC_record_replay_is_active()) return; - xbt_os_threadtimer_start(smpi_process_timer()); +#if HAVE_PAPI + if (xbt_cfg_get_string("smpi/papi-events")[0] != '\0') { + int event_set = smpi_process()->papi_event_set(); + // PAPI_start sets everything to 0! See man(3) PAPI_start + if (PAPI_LOW_LEVEL_INITED == PAPI_is_initialized()) { + if (PAPI_start(event_set) != PAPI_OK) { + // TODO This needs some proper handling. + XBT_CRITICAL("Could not start PAPI counters.\n"); + xbt_die("Error."); + } + } + } +#endif + xbt_os_threadtimer_start(smpi_process()->timer()); } -void smpi_bench_end(void) +void smpi_bench_end() { - if (MC_is_active() || MC_record_replay_is_active()) return; double speedup = 1; - xbt_os_timer_t timer = smpi_process_timer(); + xbt_os_timer_t timer = smpi_process()->timer(); xbt_os_threadtimer_stop(timer); -// smpi_switch_data_segment(smpi_process_count()); - if (smpi_process_get_sampling()) { + +#if HAVE_PAPI + /** + * An MPI function has been called and now is the right time to update + * our PAPI counters for this process. + */ + if (xbt_cfg_get_string("smpi/papi-events")[0] != '\0') { + papi_counter_t& counter_data = smpi_process()->papi_counters(); + int event_set = smpi_process()->papi_event_set(); + std::vector event_values = std::vector(counter_data.size()); + + if (PAPI_stop(event_set, &event_values[0]) != PAPI_OK) { // Error + XBT_CRITICAL("Could not stop PAPI counters.\n"); + xbt_die("Error."); + } else { + for (unsigned int i = 0; i < counter_data.size(); i++) { + counter_data[i].second += event_values[i]; + // XBT_DEBUG("[%i] PAPI: Counter %s: Value is now %lli (got increment by %lli\n", smpi_process()->index(), + // counter_data[i].first.c_str(), counter_data[i].second, event_values[i]); + } + } + } +#endif + + if (smpi_process()->sampling()) { XBT_CRITICAL("Cannot do recursive benchmarks."); XBT_CRITICAL("Are you trying to make a call to MPI within a SMPI_SAMPLE_ block?"); xbt_backtrace_display_current(); @@ -264,21 +150,35 @@ void smpi_bench_end(void) } if (xbt_cfg_get_string("smpi/comp-adjustment-file")[0] != '\0') { // Maybe we need to artificially speed up or slow - // down our computation based on our statistical analysis. + // down our computation based on our statistical analysis. - smpi_trace_call_location_t* loc = smpi_process_get_call_location(); + smpi_trace_call_location_t* loc = smpi_process()->call_location(); std::string key = loc->get_composed_key(); std::unordered_map::const_iterator it = location2speedup.find(key); if (it != location2speedup.end()) { speedup = it->second; } } - + // Simulate the benchmarked computation unless disabled via command-line argument if (xbt_cfg_get_boolean("smpi/simulate-computation")) { smpi_execute(xbt_os_timer_elapsed(timer)/speedup); } +#if HAVE_PAPI + if (xbt_cfg_get_string("smpi/papi-events")[0] != '\0' && TRACE_smpi_is_enabled()) { + char container_name[INSTR_DEFAULT_STR_SIZE]; + smpi_container(smpi_process()->index(), container_name, INSTR_DEFAULT_STR_SIZE); + container_t container = PJ_container_get(container_name); + papi_counter_t& counter_data = smpi_process()->papi_counters(); + + for (auto& pair : counter_data) { + new_pajeSetVariable(surf_get_clock(), container, + PJ_type_get(/* countername */ pair.first.c_str(), container->type), pair.second); + } + } +#endif + smpi_total_benched_time += xbt_os_timer_elapsed(timer); } @@ -288,7 +188,7 @@ static unsigned int private_sleep(double secs) smpi_bench_end(); XBT_DEBUG("Sleep for: %lf secs", secs); - int rank = smpi_comm_rank(MPI_COMM_WORLD); + int rank = MPI_COMM_WORLD->rank(); instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1); extra->type=TRACING_SLEEPING; extra->sleep_duration=secs; @@ -304,49 +204,70 @@ static unsigned int private_sleep(double secs) unsigned int smpi_sleep(unsigned int secs) { - return private_sleep((double)secs); + return private_sleep(static_cast(secs)); } int smpi_usleep(useconds_t usecs) { - return (int)private_sleep((double)usecs / 1000000.0); + return static_cast(private_sleep(static_cast(usecs) / 1000000.0)); } +#if _POSIX_TIMERS > 0 +int smpi_nanosleep(const struct timespec *tp, struct timespec * t) +{ + return static_cast(private_sleep(static_cast(tp->tv_sec + tp->tv_nsec / 1000000000.0))); +} +#endif + int smpi_gettimeofday(struct timeval *tv, void* tz) { - double now; smpi_bench_end(); - now = SIMIX_get_clock(); + double now = SIMIX_get_clock(); if (tv) { - tv->tv_sec = (time_t)now; + tv->tv_sec = static_cast(now); #ifdef WIN32 - tv->tv_usec = (useconds_t)((now - tv->tv_sec) * 1e6); + tv->tv_usec = static_cast((now - tv->tv_sec) * 1e6); #else - tv->tv_usec = (suseconds_t)((now - tv->tv_sec) * 1e6); + tv->tv_usec = static_cast((now - tv->tv_sec) * 1e6); #endif } smpi_bench_begin(); return 0; } +#if _POSIX_TIMERS > 0 +int smpi_clock_gettime(clockid_t clk_id, struct timespec *tp) +{ + //there is only one time in SMPI, so clk_id is ignored. + smpi_bench_end(); + double now = SIMIX_get_clock(); + if (tp) { + tp->tv_sec = static_cast(now); + tp->tv_nsec = static_cast((now - tp->tv_sec) * 1e9); + } + smpi_bench_begin(); + return 0; +} +#endif + extern double sg_surf_precision; -unsigned long long smpi_rastro_resolution (void) +unsigned long long smpi_rastro_resolution () { smpi_bench_end(); double resolution = (1/sg_surf_precision); smpi_bench_begin(); - return (unsigned long long)resolution; + return static_cast(resolution); } -unsigned long long smpi_rastro_timestamp (void) +unsigned long long smpi_rastro_timestamp () { smpi_bench_end(); double now = SIMIX_get_clock(); - unsigned long long sec = (unsigned long long)now; + unsigned long long sec = static_cast(now); unsigned long long pre = (now - sec) * smpi_rastro_resolution(); smpi_bench_begin(); - return (unsigned long long)sec * smpi_rastro_resolution() + pre; + return static_cast(sec) * smpi_rastro_resolution() + pre; } /* ****************************** Functions related to the SMPI_SAMPLE_ macros ************************************/ @@ -365,7 +286,7 @@ static char *sample_location(int global, const char *file, int line) { if (global) { return bprintf("%s:%d", file, line); } else { - return bprintf("%s:%d:%d", file, line, smpi_process_index()); + return bprintf("%s:%d:%d", file, line, smpi_process()->index()); } } @@ -385,19 +306,18 @@ static int sample_enough_benchs(local_data_t *data) { void smpi_sample_1(int global, const char *file, int line, int iters, double threshold) { char *loc = sample_location(global, file, line); - local_data_t *data; smpi_bench_end(); /* Take time from previous, unrelated computation into account */ - smpi_process_set_sampling(1); + smpi_process()->set_sampling(1); - if (!samples) + if (samples==nullptr) samples = xbt_dict_new_homogeneous(free); - data = static_cast(xbt_dict_get_or_null(samples, loc)); - if (!data) { + local_data_t *data = static_cast(xbt_dict_get_or_null(samples, loc)); + if (data==nullptr) { xbt_assert(threshold>0 || iters>0, "You should provide either a positive amount of iterations to bench, or a positive maximal stderr (or both)"); - data = (local_data_t *) xbt_new(local_data_t, 1); + data = static_cast( xbt_new(local_data_t, 1)); data->count = 0; data->sum = 0.0; data->sum_pow2 = 0.0; @@ -405,21 +325,21 @@ void smpi_sample_1(int global, const char *file, int line, int iters, double thr data->threshold = threshold; data->benching = 1; // If we have no data, we need at least one data->mean = 0; - xbt_dict_set(samples, loc, data, NULL); + xbt_dict_set(samples, loc, data, nullptr); XBT_DEBUG("XXXXX First time ever on benched nest %s.",loc); } else { if (data->iters != iters || data->threshold != threshold) { 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??", - loc, data->iters, data->threshold, iters,threshold); + loc, data->iters, data->threshold, iters, threshold); THROW_IMPOSSIBLE; } // if we already have some data, check whether sample_2 should get one more bench or whether it should emulate // the computation instead - data->benching = !sample_enough_benchs(data); - XBT_DEBUG("XXXX Re-entering the benched nest %s. %s",loc, - (data->benching?"more benching needed":"we have enough data, skip computes")); + data->benching = (sample_enough_benchs(data) == 0); + XBT_DEBUG("XXXX Re-entering the benched nest %s. %s", loc, + (data->benching ? "more benching needed" : "we have enough data, skip computes")); } xbt_free(loc); } @@ -427,11 +347,10 @@ void smpi_sample_1(int global, const char *file, int line, int iters, double thr int smpi_sample_2(int global, const char *file, int line) { char *loc = sample_location(global, file, line); - local_data_t *data; int res; xbt_assert(samples, "Y U NO use SMPI_SAMPLE_* macros? Stop messing directly with smpi_sample_* functions!"); - data = static_cast(xbt_dict_get(samples, loc)); + local_data_t *data = static_cast(xbt_dict_get(samples, loc)); XBT_DEBUG("sample2 %s",loc); xbt_free(loc); @@ -444,9 +363,10 @@ int smpi_sample_2(int global, const char *file, int line) // 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). Just sleep instead XBT_DEBUG("No benchmark (either no need, or just ran one): count >= iter (%d >= %d) or stderrcount, data->iters, data->relstderr, data->threshold, data->mean); + " apply the %fs delay instead", + data->count, data->iters, data->relstderr, data->threshold, data->mean); smpi_execute(data->mean); - smpi_process_set_sampling(0); + smpi_process()->set_sampling(0); res = 0; // prepare to capture future, unrelated computations } smpi_bench_begin(); @@ -456,32 +376,29 @@ int smpi_sample_2(int global, const char *file, int line) void smpi_sample_3(int global, const char *file, int line) { char *loc = sample_location(global, file, line); - local_data_t *data; xbt_assert(samples, "Y U NO use SMPI_SAMPLE_* macros? Stop messing directly with smpi_sample_* functions!"); - data = static_cast(xbt_dict_get(samples, loc)); + local_data_t *data = static_cast(xbt_dict_get(samples, loc)); XBT_DEBUG("sample3 %s",loc); xbt_free(loc); - if (data->benching==0) { + if (data->benching==0) THROW_IMPOSSIBLE; - } // ok, benchmarking this loop is over - xbt_os_threadtimer_stop(smpi_process_timer()); + xbt_os_threadtimer_stop(smpi_process()->timer()); // update the stats - double sample, n; data->count++; - sample = xbt_os_timer_elapsed(smpi_process_timer()); + double sample = xbt_os_timer_elapsed(smpi_process()->timer()); data->sum += sample; data->sum_pow2 += sample * sample; - n = (double)data->count; + double n = static_cast(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)) { + if (sample_enough_benchs(data)==0) { 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 + // 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); @@ -490,261 +407,13 @@ void smpi_sample_3(int global, const char *file, int line) data->benching = 0; } -#ifndef WIN32 - -void *smpi_shared_malloc(size_t size, const char *file, int line) -{ - void* mem; - if (xbt_cfg_get_boolean("smpi/use-shared-malloc")){ - int fd; - smpi_source_location loc(file, line); - auto res = allocs.insert(std::make_pair(loc, shared_data_t())); - auto data = res.first; - if (res.second) { - // The insertion did not take place. - // Generate a shared memory name from the address of the shared_data: - char shmname[32]; // cannot be longer than PSHMNAMLEN = 31 on Mac OS X (shm_open raises ENAMETOOLONG otherwise) - snprintf(shmname, 31, "/shmalloc%p", &*data); - fd = shm_open(shmname, 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", shmname); - default: - xbt_die("An unhandled error occurred while opening %s. shm_open: %s", shmname, strerror(errno)); - } - } - data->second.fd = fd; - data->second.count = 1; - mem = shm_map(fd, size, &*data); - if (shm_unlink(shmname) < 0) { - XBT_WARN("Could not early unlink %s. shm_unlink: %s", shmname, strerror(errno)); - } - XBT_DEBUG("Mapping %s at %p through %d", shmname, mem, fd); - } else { - mem = shm_map(data->second.fd, size, &*data); - data->second.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]; - - if (xbt_cfg_get_boolean("smpi/use-shared-malloc")){ - snprintf(loc, PTR_STRLEN, "%p", ptr); - auto meta = allocs_metadata.find(ptr); - if (meta == allocs_metadata.end()) { - XBT_WARN("Cannot free: %p was not shared-allocated by SMPI", ptr); - return; - } - shared_data_t* data = &meta->second.data->second; - if (munmap(ptr, meta->second.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); - allocs.erase(allocs.find(meta->second.data->first)); - 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) - -/** Map a given SMPI privatization segment (make a SMPI process active) */ -void smpi_switch_data_segment(int dest){ - if (smpi_loaded_page==dest)//no need to switch either - return; - - // So the job: - smpi_really_switch_data_segment(dest); -} - -/** Map a given SMPI privatization segment (make a SMPI process active) even if SMPI thinks it is already active - * - * When doing a state restoration, the state of the restored variables might not be consistent with the state of the - * virtual memory. In this case, we to change the data segment. - */ -void smpi_really_switch_data_segment(int dest) { - if(smpi_size_data_exe == 0)//no need to switch - return; - -#if HAVE_PRIVATIZATION - if(smpi_loaded_page==-1){//initial switch, do the copy from the real page here - for (int i=0; i< smpi_process_count(); i++){ - memcpy(smpi_privatisation_regions[i].address, TOPAGE(smpi_start_data_exe), smpi_size_data_exe); - } - } - - // FIXME, cross-process support (mmap across process when necessary) - int current = smpi_privatisation_regions[dest].file_descriptor; - XBT_DEBUG("Switching data frame to the one of process %d", dest); - void* tmp = mmap (TOPAGE(smpi_start_data_exe), smpi_size_data_exe, - PROT_READ | PROT_WRITE, MAP_FIXED | MAP_SHARED, current, 0); - if (tmp != TOPAGE(smpi_start_data_exe)) - xbt_die("Couldn't map the new region"); - smpi_loaded_page = dest; -#endif -} - -int smpi_is_privatisation_file(char* file) -{ - return strncmp("/dev/shm/my-buffer-", file, 19) == 0; -} - -void smpi_initialize_global_memory_segments(){ - -#if !HAVE_PRIVATIZATION - smpi_privatize_global_variables=0; - xbt_die("You are trying to use privatization on a system that does not support it. Don't."); - return; -#else - - smpi_get_executable_global_size(); - - XBT_DEBUG ("bss+data segment found : size %d starting at %p", smpi_size_data_exe, smpi_start_data_exe ); - - if (smpi_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 (int i=0; i< smpi_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) { - if (errno==EMFILE) { - xbt_die("Impossible to create temporary file for memory mapping: %s\n\ -The open() system call failed with the EMFILE error code (too many files). \n\n\ -This means that you reached the system limits concerning the amount of files per process. \ -This is not a surprise if you are trying to virtualize many processes on top of SMPI. \ -Don't panic -- you should simply increase your system limits and try again. \n\n\ -First, check what your limits are:\n\ - cat /proc/sys/fs/file-max # Gives you the system-wide limit\n\ - ulimit -Hn # Gives you the per process hard limit\n\ - ulimit -Sn # Gives you the per process soft limit\n\ - cat /proc/self/limits # Displays any per-process limitation (including the one given above)\n\n\ -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. \ -Ask the Internet about tutorials on how to increase the files limit such as: https://rtcamp.com/tutorials/linux/increase-open-files-limit/", - strerror(errno)); - } - xbt_die("Impossible to create temporary file for memory mapping: %s", - strerror(errno)); - } - - status = unlink (path); - if (status) - xbt_die("Impossible to unlink temporary file for memory mapping"); - - status = ftruncate(file_descriptor, smpi_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, smpi_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(smpi_start_data_exe), smpi_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 -} - -void smpi_destroy_global_memory_segments(){ - if (smpi_size_data_exe == 0)//no need to switch - return; -#if HAVE_PRIVATIZATION - int i; - for (i=0; i< smpi_process_count(); i++){ - if(munmap(smpi_privatisation_regions[i].address, smpi_size_data_exe) < 0) { - XBT_WARN("Unmapping of fd %d failed: %s", smpi_privatisation_regions[i].file_descriptor, strerror(errno)); - } - close(smpi_privatisation_regions[i].file_descriptor); +extern "C" { /** These functions will be called from the user code **/ + smpi_trace_call_location_t* smpi_trace_get_call_location() { + return smpi_process()->call_location(); } - xbt_free(smpi_privatisation_regions); -#endif -} - -smpi_trace_call_location_t* smpi_trace_get_call_location() { - return smpi_process_get_call_location(); -} -extern "C" { /** These functions will be called from the user code **/ void smpi_trace_set_call_location(const char* file, const int line) { - smpi_trace_call_location_t* loc = smpi_process_get_call_location(); + smpi_trace_call_location_t* loc = smpi_process()->call_location(); loc->previous_filename = loc->filename; loc->previous_linenumber = loc->linenumber;