X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/4d140762b2b9c8746cdd3b0680a7167867ba0ad9..7014d6c208b0a513ee1988930af20c1e4be0c7e8:/src/smpi/internals/smpi_bench.cpp diff --git a/src/smpi/internals/smpi_bench.cpp b/src/smpi/internals/smpi_bench.cpp index b570e7b1ea..8e17376e70 100644 --- a/src/smpi/internals/smpi_bench.cpp +++ b/src/smpi/internals/smpi_bench.cpp @@ -3,18 +3,19 @@ /* 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 "src/internal_config.h" #include "private.h" #include "private.hpp" #include "simgrid/modelchecker.h" -#include "src/mc/mc_replay.h" -#include "smpi_process.hpp" #include "smpi_comm.hpp" +#include "smpi_process.hpp" +#include "src/internal_config.h" +#include "src/mc/mc_replay.h" +#include #ifndef WIN32 #include #endif -#include // sqrt +#include #if HAVE_PAPI #include @@ -22,9 +23,6 @@ XBT_LOG_NEW_DEFAULT_SUBCATEGORY(smpi_bench, smpi, "Logging specific to SMPI (benchmarking)"); - -xbt_dict_t samples = nullptr; /* Allocated on first use */ - double smpi_cpu_threshold = -1; double smpi_host_speed; @@ -32,11 +30,6 @@ shared_malloc_type smpi_cfg_shared_malloc = shmalloc_global; double smpi_total_benched_time = 0; smpi_privatization_region_t smpi_privatization_regions; -void smpi_bench_destroy() -{ - xbt_dict_free(&samples); -} - extern "C" XBT_PUBLIC(void) smpi_execute_flops_(double *flops); void smpi_execute_flops_(double *flops) { @@ -73,7 +66,7 @@ void smpi_execute(double duration) TRACE_smpi_computing_out(rank); } else { - XBT_DEBUG("Real computation took %g while option smpi/cpu_threshold is set to %g => ignore it", duration, + XBT_DEBUG("Real computation took %g while option smpi/cpu-threshold is set to %g => ignore it", duration, smpi_cpu_threshold); } } @@ -282,11 +275,14 @@ typedef struct { int benching; /* 1: we are benchmarking; 0: we have enough data, no bench anymore */ } local_data_t; -static char *sample_location(int global, const char *file, int line) { +std::unordered_map samples; /* Allocated on first use */ + +static std::string sample_location(int global, const char* file, int line) +{ if (global) { - return bprintf("%s:%d", file, line); + return std::string(file) + ":" + std::to_string(line); } else { - return bprintf("%s:%d:%d", file, line, smpi_process()->index()); + return std::string(file) + ":" + std::to_string(line) + ":" + std::to_string(smpi_process()->index()); } } @@ -305,19 +301,17 @@ 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); + std::string loc = sample_location(global, file, line); smpi_bench_end(); /* Take time from previous, unrelated computation into account */ smpi_process()->set_sampling(1); - if (samples==nullptr) - samples = xbt_dict_new_homogeneous(free); - - local_data_t *data = static_cast(xbt_dict_get_or_null(samples, loc)); - if (data==nullptr) { + auto ld = samples.find(loc); + local_data_t* data; + if (ld == samples.end()) { 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)); + data = static_cast(xbt_new(local_data_t, 1)); data->count = 0; data->sum = 0.0; data->sum_pow2 = 0.0; @@ -325,34 +319,34 @@ 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, nullptr); - XBT_DEBUG("XXXXX First time ever on benched nest %s.",loc); + samples[loc] = data; + XBT_DEBUG("XXXXX First time ever on benched nest %s.", loc.c_str()); } else { + data = ld->second; 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.c_str(), 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) == 0); - XBT_DEBUG("XXXX Re-entering the benched nest %s. %s", loc, + XBT_DEBUG("XXXX Re-entering the benched nest %s. %s", loc.c_str(), (data->benching ? "more benching needed" : "we have enough data, skip computes")); } - xbt_free(loc); } int smpi_sample_2(int global, const char *file, int line) { - char *loc = sample_location(global, file, line); + std::string loc = sample_location(global, file, line); int res; - xbt_assert(samples, "Y U NO use SMPI_SAMPLE_* macros? Stop messing directly with smpi_sample_* functions!"); - local_data_t *data = static_cast(xbt_dict_get(samples, loc)); - XBT_DEBUG("sample2 %s",loc); - xbt_free(loc); + xbt_assert(not samples.empty(), + "Y U NO use SMPI_SAMPLE_* macros? Stop messing directly with smpi_sample_* functions!"); + local_data_t* data = samples.at(loc); + XBT_DEBUG("sample2 %s", loc.c_str()); if (data->benching==1) { // we need to run a new bench @@ -375,12 +369,12 @@ 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); + std::string loc = sample_location(global, file, line); - xbt_assert(samples, "Y U NO use SMPI_SAMPLE_* macros? Stop messing directly with smpi_sample_* functions!"); - local_data_t *data = static_cast(xbt_dict_get(samples, loc)); - XBT_DEBUG("sample3 %s",loc); - xbt_free(loc); + xbt_assert(not samples.empty(), + "Y U NO use SMPI_SAMPLE_* macros? Stop messing directly with smpi_sample_* functions!"); + local_data_t* data = samples.at(loc); + XBT_DEBUG("sample3 %s", loc.c_str()); if (data->benching==0) THROW_IMPOSSIBLE; @@ -408,30 +402,36 @@ void smpi_sample_3(int global, const char *file, int line) } 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(); - } +smpi_trace_call_location_t* smpi_trace_get_call_location() +{ + return smpi_process()->call_location(); +} - void smpi_trace_set_call_location(const char* file, const int line) { - smpi_trace_call_location_t* loc = smpi_process()->call_location(); +void smpi_trace_set_call_location(const char* file, const int line) +{ + smpi_trace_call_location_t* loc = smpi_process()->call_location(); - loc->previous_filename = loc->filename; - loc->previous_linenumber = loc->linenumber; - loc->filename = file; - loc->linenumber = line; - } + loc->previous_filename = loc->filename; + loc->previous_linenumber = loc->linenumber; + loc->filename = file; + loc->linenumber = line; +} - /** - * Required for Fortran bindings - */ - void smpi_trace_set_call_location_(const char* file, int* line) { - smpi_trace_set_call_location(file, *line); - } +/** Required for Fortran bindings */ +void smpi_trace_set_call_location_(const char* file, int* line) +{ + smpi_trace_set_call_location(file, *line); +} - /** - * Required for Fortran if -fsecond-underscore is activated - */ - void smpi_trace_set_call_location__(const char* file, int* line) { - smpi_trace_set_call_location(file, *line); - } +/** Required for Fortran if -fsecond-underscore is activated */ +void smpi_trace_set_call_location__(const char* file, int* line) +{ + smpi_trace_set_call_location(file, *line); +} +} + +void smpi_bench_destroy() +{ + for (auto elm : samples) + xbt_free(elm.second); }