X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/de5e36cc7e45014c43cf9290b5ac8380072d69ad..c8d6bade6ee8fff928228bec67e9b2e86484793d:/src/smpi/smpi_bench.cpp diff --git a/src/smpi/smpi_bench.cpp b/src/smpi/smpi_bench.cpp index b321e241ec..3128889670 100644 --- a/src/smpi/smpi_bench.cpp +++ b/src/smpi/smpi_bench.cpp @@ -32,6 +32,10 @@ #include #include +#if HAVE_PAPI +#include +#endif + #ifndef MAP_ANONYMOUS #define MAP_ANONYMOUS MAP_ANON #endif @@ -71,16 +75,16 @@ XBT_LOG_NEW_DEFAULT_SUBCATEGORY(smpi_bench, smpi, "Logging specific to SMPI (ben #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 */ +xbt_dict_t samples = nullptr; /* Allocated on first use */ +xbt_dict_t calls = nullptr; /* Allocated on first use */ double smpi_cpu_threshold; double smpi_running_power; int smpi_loaded_page = -1; -char* smpi_start_data_exe = NULL; +char* smpi_start_data_exe = nullptr; int smpi_size_data_exe = 0; -int smpi_privatize_global_variables; +bool smpi_privatize_global_variables; double smpi_total_benched_time = 0; smpi_privatisation_region_t smpi_privatisation_regions; @@ -168,7 +172,7 @@ static void* shm_map(int fd, size_t size, shared_data_key_type* data) { 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); + mem = mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); if(mem == MAP_FAILED) { xbt_die("Could not map fd %d: %s", fd, strerror(errno)); } @@ -230,8 +234,6 @@ void smpi_execute(double duration) } } -void smpi_switch_data_segment(int dest); - void smpi_bench_begin(void) { if (smpi_privatize_global_variables) { @@ -241,18 +243,54 @@ void smpi_bench_begin(void) if (MC_is_active() || MC_record_replay_is_active()) return; +#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) { - if (MC_is_active() || MC_record_replay_is_active()) return; double speedup = 1; xbt_os_timer_t timer = smpi_process_timer(); xbt_os_threadtimer_stop(timer); + +#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_get_sampling()) { XBT_CRITICAL("Cannot do recursive benchmarks."); XBT_CRITICAL("Are you trying to make a call to MPI within a SMPI_SAMPLE_ block?"); @@ -276,6 +314,20 @@ void smpi_bench_end(void) 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); } @@ -309,6 +361,13 @@ int smpi_usleep(useconds_t usecs) 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; @@ -326,6 +385,22 @@ int smpi_gettimeofday(struct timeval *tv, void* tz) 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. + double now; + smpi_bench_end(); + 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) { @@ -387,11 +462,11 @@ void smpi_sample_1(int global, const char *file, int line, int iters, double thr smpi_bench_end(); /* Take time from previous, unrelated computation into account */ smpi_process_set_sampling(1); - if (samples==NULL) + if (samples==nullptr) samples = xbt_dict_new_homogeneous(free); data = static_cast(xbt_dict_get_or_null(samples, loc)); - if (data==NULL) { + 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 = static_cast( xbt_new(local_data_t, 1)); @@ -402,7 +477,7 @@ 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) { @@ -414,7 +489,7 @@ void smpi_sample_1(int global, const char *file, int line, int iters, double thr // 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); + 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")); } @@ -561,23 +636,24 @@ void smpi_shared_free(void *ptr) 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==NULL) { - calls = xbt_dict_new_homogeneous(NULL); + if (calls==nullptr) { + calls = xbt_dict_new_homogeneous(nullptr); } - TRY { + try { xbt_dict_get(calls, loc); /* Succeed or throw */ known = 1; - } - TRY_CLEANUP { xbt_free(loc); } - CATCH(ex) { + catch (xbt_ex& ex) { + xbt_free(loc); if (ex.category != not_found_error) - RETHROW; - xbt_ex_free(ex); + throw; + } + catch(...) { + xbt_free(loc); + throw; } return known; } @@ -586,8 +662,8 @@ void* smpi_shared_get_call(const char* func, const char* input) { char* loc = bprintf("%s:%s", func, input); void* data; - if(calls==NULL) { - calls = xbt_dict_new_homogeneous(NULL); + if(calls==nullptr) { + calls = xbt_dict_new_homogeneous(nullptr); } data = xbt_dict_get(calls, loc); xbt_free(loc); @@ -597,20 +673,19 @@ void* smpi_shared_get_call(const char* func, const char* input) { 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); + if(calls==0) { + calls = xbt_dict_new_homogeneous(nullptr); } - xbt_dict_set(calls, loc, data, NULL); + xbt_dict_set(calls, loc, data, nullptr); xbt_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; +void smpi_switch_data_segment(int dest) { + if (smpi_loaded_page == dest)//no need to switch, we've already loaded the one we want + return; // So the job: smpi_really_switch_data_segment(dest); @@ -645,13 +720,13 @@ void smpi_really_switch_data_segment(int dest) { int smpi_is_privatisation_file(char* file) { - return strncmp("/dev/shm/my-buffer-", file, 19) == 0; + return strncmp("/dev/shm/my-buffer-", file, std::strlen("/dev/shm/my-buffer-")) == 0; } void smpi_initialize_global_memory_segments(){ #if !HAVE_PRIVATIZATION - smpi_privatize_global_variables=0; + smpi_privatize_global_variables=false; xbt_die("You are trying to use privatization on a system that does not support it. Don't."); return; #else @@ -661,7 +736,7 @@ void smpi_initialize_global_memory_segments(){ 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; + smpi_privatize_global_variables=false; return; } @@ -670,7 +745,7 @@ void smpi_initialize_global_memory_segments(){ 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; + void *address = nullptr; char path[] = "/dev/shm/my-buffer-XXXXXX"; int status; @@ -704,7 +779,7 @@ Ask the Internet about tutorials on how to increase the files limit such as: htt 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); + address = mmap (nullptr, 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");