Commit 19f76a4a authored by Augustin Degomme's avatar Augustin Degomme

Move SMPI config to smpi_config.cpp file.

Store values for most used values, which can be used millions of times.
In some tests I saw up to 5% of the time spent reading them.
parent 23eddc1d
......@@ -12,6 +12,7 @@
#include "src/kernel/lmm/maxmin.hpp"
#include "src/mc/mc_config.hpp"
#include "src/mc/mc_replay.hpp"
#include "src/smpi/include/smpi_config.hpp"
#include "src/surf/surf_interface.hpp"
#include "surf/surf.hpp"
#include "xbt/config.hpp"
......@@ -365,111 +366,6 @@ void sg_config_init(int *argc, char **argv)
"contention (default value based on Stampede cluster profiling)",
"0.965;0.925;1.35");
simgrid::config::alias("smpi/IB-penalty-factors", {"smpi/IB_penalty_factors"});
#if HAVE_SMPI
simgrid::config::declare_flag<double>("smpi/host-speed", "Speed of the host running the simulation (in flop/s). "
"Used to bench the operations.",
20000.0, [](const double& val) {
xbt_assert(val > 0.0, "Invalid value (%f) for 'smpi/host-speed': it must be positive.", val);
});
simgrid::config::alias("smpi/host-speed", {"smpi/running_power", "smpi/running-power"});
simgrid::config::declare_flag<bool>("smpi/keep-temps", "Whether we should keep the generated temporary files.",
false);
simgrid::config::declare_flag<bool>("smpi/display-timing", "Whether we should display the timing after simulation.",
false);
simgrid::config::alias("smpi/display-timing", {"smpi/display_timing"});
simgrid::config::declare_flag<bool>(
"smpi/simulate-computation", "Whether the computational part of the simulated application should be simulated.",
true);
simgrid::config::alias("smpi/simulate-computation", {"smpi/simulate_computation"});
simgrid::config::declare_flag<std::string>(
"smpi/shared-malloc", "Whether SMPI_SHARED_MALLOC is enabled. Disable it for debugging purposes.", "global");
simgrid::config::alias("smpi/shared-malloc", {"smpi/use_shared_malloc", "smpi/use-shared-malloc"});
simgrid::config::declare_flag<double>("smpi/shared-malloc-blocksize",
"Size of the bogus file which will be created for global shared allocations",
1UL << 20);
simgrid::config::declare_flag<double>("smpi/auto-shared-malloc-thresh",
"Threshold size for the automatic sharing of memory",
0);
simgrid::config::declare_flag<std::string>("smpi/shared-malloc-hugepage",
"Path to a mounted hugetlbfs, to use huge pages with shared malloc.", "");
simgrid::config::declare_flag<double>(
"smpi/cpu-threshold", "Minimal computation time (in seconds) not discarded, or -1 for infinity.", 1e-6);
simgrid::config::alias("smpi/cpu-threshold", {"smpi/cpu_threshold"});
simgrid::config::declare_flag<int>(
"smpi/async-small-thresh",
"Maximal size of messages that are to be sent asynchronously, without waiting for the receiver", 0);
simgrid::config::alias("smpi/async-small-thresh", {"smpi/async_small_thres", "smpi/async_small_thresh"});
simgrid::config::declare_flag<bool>("smpi/trace-call-location",
"Should filename and linenumber of MPI calls be traced?", false);
simgrid::config::declare_flag<bool>("smpi/trace-call-use-absolute-path",
"Should filenames for trace-call tracing be absolute or not?", false);
simgrid::config::declare_flag<int>(
"smpi/send-is-detached-thresh",
"Threshold of message size where MPI_Send stops behaving like MPI_Isend and becomes MPI_Ssend", 65536);
simgrid::config::alias("smpi/send-is-detached-thresh",
{"smpi/send_is_detached_thres", "smpi/send_is_detached_thresh"});
const char* default_privatization = std::getenv("SMPI_PRIVATIZATION");
if (default_privatization == nullptr)
default_privatization = "no";
simgrid::config::declare_flag<std::string>(
"smpi/privatization", "How we should privatize global variable at runtime (no, yes, mmap, dlopen).",
default_privatization);
simgrid::config::alias("smpi/privatization", {"smpi/privatize_global_variables", "smpi/privatize-global-variables"});
simgrid::config::declare_flag<std::string>(
"smpi/privatize-libs", "Add libraries (; separated) to privatize (libgfortran for example). You need to provide the full names of the files (libgfortran.so.4), or its full path", "");
simgrid::config::declare_flag<bool>("smpi/grow-injected-times",
"Whether we want to make the injected time in MPI_Iprobe and MPI_Test grow, to "
"allow faster simulation. This can make simulation less precise, though.",
true);
#if HAVE_PAPI
simgrid::config::declare_flag<std::string>("smpi/papi-events",
"This switch enables tracking the specified counters with PAPI", "");
#endif
simgrid::config::declare_flag<std::string>("smpi/comp-adjustment-file",
"A file containing speedups or slowdowns for some parts of the code.", "");
simgrid::config::declare_flag<std::string>(
"smpi/os", "Small messages timings (MPI_Send minimum time for small messages)", "0:0:0:0:0");
simgrid::config::declare_flag<std::string>(
"smpi/ois", "Small messages timings (MPI_Isend minimum time for small messages)", "0:0:0:0:0");
simgrid::config::declare_flag<std::string>(
"smpi/or", "Small messages timings (MPI_Recv minimum time for small messages)", "0:0:0:0:0");
simgrid::config::declare_flag<double>("smpi/iprobe-cpu-usage",
"Maximum usage of CPUs by MPI_Iprobe() calls. We've observed that MPI_Iprobes "
"consume significantly less power than the maximum of a specific application. "
"This value is then (Iprobe_Usage/Max_Application_Usage).",
1.0);
simgrid::config::declare_flag<std::string>("smpi/coll-selector", "Which collective selector to use", "default");
simgrid::config::alias("smpi/coll-selector", {"smpi/coll_selector"});
simgrid::config::declare_flag<std::string>("smpi/gather", "Which collective to use for gather", "");
simgrid::config::declare_flag<std::string>("smpi/allgather", "Which collective to use for allgather", "");
simgrid::config::declare_flag<std::string>("smpi/barrier", "Which collective to use for barrier", "");
simgrid::config::declare_flag<std::string>("smpi/reduce_scatter", "Which collective to use for reduce_scatter", "");
simgrid::config::alias("smpi/reduce_scatter", {"smpi/reduce-scatter"});
simgrid::config::declare_flag<std::string>("smpi/scatter", "Which collective to use for scatter", "");
simgrid::config::declare_flag<std::string>("smpi/allgatherv", "Which collective to use for allgatherv", "");
simgrid::config::declare_flag<std::string>("smpi/allreduce", "Which collective to use for allreduce", "");
simgrid::config::declare_flag<std::string>("smpi/alltoall", "Which collective to use for alltoall", "");
simgrid::config::declare_flag<std::string>("smpi/alltoallv", "Which collective to use for alltoallv", "");
simgrid::config::declare_flag<std::string>("smpi/bcast", "Which collective to use for bcast", "");
simgrid::config::declare_flag<std::string>("smpi/reduce", "Which collective to use for reduce", "");
#endif // HAVE_SMPI
/* Others */
simgrid::config::declare_flag<bool>(
......
......@@ -72,7 +72,7 @@ static void segvhandler(int signum, siginfo_t* siginfo, void* /*context*/)
} else if (siginfo->si_signo == SIGSEGV) {
fprintf(stderr, "Segmentation fault.\n");
#if HAVE_SMPI
if (smpi_enabled() && smpi_privatize_global_variables == SmpiPrivStrategies::NONE) {
if (smpi_enabled() && smpi_cfg_privatization() == SmpiPrivStrategies::NONE) {
#if HAVE_PRIVATIZATION
fprintf(stderr, "Try to enable SMPI variable privatization with --cfg=smpi/privatization:yes.\n");
#else
......
......@@ -93,15 +93,30 @@ XBT_PRIVATE int smpi_enabled();
XBT_PRIVATE double smpi_mpi_wtime();
XBT_PRIVATE void smpi_mpi_init();
enum class SharedMallocType { NONE, LOCAL, GLOBAL };
enum class SmpiPrivStrategies { NONE = 0, MMAP = 1, DLOPEN = 2, DEFAULT = DLOPEN };
XBT_PRIVATE void smpi_init_options();
XBT_PRIVATE void smpi_check_options();
XBT_PRIVATE double smpi_cfg_host_speed();
XBT_PRIVATE bool smpi_cfg_simulate_computation();
XBT_PRIVATE SharedMallocType smpi_cfg_shared_malloc();
XBT_PRIVATE double smpi_cfg_cpu_thresh();
XBT_PRIVATE SmpiPrivStrategies smpi_cfg_privatization();
XBT_PRIVATE int smpi_cfg_async_small_thresh();
XBT_PRIVATE int smpi_cfg_detached_send_thresh();
XBT_PRIVATE bool smpi_cfg_grow_injected_times();
XBT_PRIVATE double smpi_cfg_iprobe_cpu_usage();
XBT_PRIVATE bool smpi_cfg_trace_call_location();
XBT_PRIVATE bool smpi_cfg_trace_call_use_absolute_path();
XBT_PRIVATE std::string smpi_cfg_comp_adjustment_file();
XBT_PRIVATE std::string smpi_cfg_papi_events_file();
XBT_PRIVATE double smpi_cfg_auto_shared_malloc_thresh();
// utilities
extern XBT_PRIVATE double smpi_cpu_threshold;
extern XBT_PRIVATE double smpi_host_speed;
extern XBT_PRIVATE char* smpi_data_exe_start; // start of the data+bss segment of the executable
extern XBT_PRIVATE int smpi_data_exe_size; // size of the data+bss segment of the executable
enum class SharedMallocType { NONE, LOCAL, GLOBAL };
extern XBT_PRIVATE SharedMallocType smpi_cfg_shared_malloc; // Whether to activate shared malloc
XBT_PRIVATE void smpi_switch_data_segment(simgrid::s4u::ActorPtr actor);
XBT_PRIVATE void smpi_prepare_global_memory_segment();
......@@ -480,10 +495,6 @@ extern std::unordered_map<std::string, double> location2speedup;
/** @brief Returns the last call location (filename, linenumber). Process-specific. */
XBT_PUBLIC smpi_trace_call_location_t* smpi_trace_get_call_location();
enum class SmpiPrivStrategies { NONE = 0, MMAP = 1, DLOPEN = 2, DEFAULT = DLOPEN };
extern XBT_PRIVATE SmpiPrivStrategies smpi_privatize_global_variables;
XBT_PRIVATE void private_execute_flops(double flops);
#endif
/* Copyright (c) 2018-2019. 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. */
#ifndef SMPI_CONFIG_HPP
#define SMPI_CONFIG_HPP
#include <xbt/config.hpp>
/********************************** Configuration of SMPI **************************************/
extern XBT_PRIVATE simgrid::config::Flag<double> _smpi_cfg_host_speed;
extern XBT_PRIVATE simgrid::config::Flag<bool> _smpi_cfg_simulate_computation;
extern XBT_PRIVATE simgrid::config::Flag<std::string> _smpi_cfg_shared_malloc_string;
extern XBT_PRIVATE simgrid::config::Flag<double> _smpi_cfg_cpu_thresh;
extern XBT_PRIVATE simgrid::config::Flag<std::string> _smpi_cfg_privatization_string;
extern XBT_PRIVATE simgrid::config::Flag<int> _smpi_cfg_async_small_thresh;
extern XBT_PRIVATE simgrid::config::Flag<int> _smpi_cfg_detached_send_thresh;
extern XBT_PRIVATE simgrid::config::Flag<bool> _smpi_cfg_grow_injected_times;
extern XBT_PRIVATE simgrid::config::Flag<double> _smpi_cfg_iprobe_cpu_usage;
extern XBT_PRIVATE simgrid::config::Flag<bool> _smpi_cfg_trace_call_use_absolute_path;
extern XBT_PRIVATE simgrid::config::Flag<bool> _smpi_cfg_trace_call_location;
extern XBT_PRIVATE simgrid::config::Flag<std::string> _smpi_cfg_comp_adjustment_file;
#if HAVE_PAPI
extern XBT_PRIVATE simgrid::config::Flag<std::string> _smpi_cfg_papi_events_file;
#endif
extern XBT_PRIVATE simgrid::config::Flag<double> _smpi_cfg_auto_shared_malloc_thresh;
#endif
......@@ -36,7 +36,7 @@ ActorExt::ActorExt(s4u::Actor* actor) : actor_(actor)
MC_ignore_heap(timer_, xbt_os_timer_size());
#if HAVE_PAPI
if (not simgrid::config::get_value<std::string>("smpi/papi-events").empty()) {
if (not smpi_cfg_papi_events_file().empty()) {
// TODO: Implement host/process/thread based counters. This implementation
// just always takes the values passed via "default", like this:
// "default:COUNTER1:COUNTER2:COUNTER3;".
......@@ -221,7 +221,7 @@ void ActorExt::init()
if (ext->initialized())
return;
if (smpi_privatize_global_variables == SmpiPrivStrategies::MMAP) {
if (smpi_cfg_privatization() == SmpiPrivStrategies::MMAP) {
/* Now using the segment index of this process */
ext->set_privatized_region(smpi_init_global_memory_segment_process());
/* Done at the process's creation */
......
......@@ -33,10 +33,6 @@ static simgrid::config::Flag<double>
"Minimum time to inject inside a call to MPI_Wtime(), gettimeofday() and clock_gettime()",
1e-8 /* Documented to be 10 ns */);
double smpi_cpu_threshold = -1;
double smpi_host_speed;
SharedMallocType smpi_cfg_shared_malloc = SharedMallocType::GLOBAL;
double smpi_total_benched_time = 0;
// Private execute_flops used by smpi_execute and smpi_execute_benched
......@@ -62,9 +58,9 @@ void smpi_execute_flops(double flops) {
void smpi_execute(double duration)
{
if (duration >= smpi_cpu_threshold) {
if (duration >= smpi_cfg_cpu_thresh()) {
XBT_DEBUG("Sleep for %g to handle real computation time", duration);
double flops = duration * smpi_host_speed;
double flops = duration * smpi_cfg_host_speed();
int rank = simgrid::s4u::this_actor::get_pid();
TRACE_smpi_computing_in(rank, flops);
......@@ -74,7 +70,7 @@ void smpi_execute(double duration)
} else {
XBT_DEBUG("Real computation took %g while option smpi/cpu-threshold is set to %g => ignore it", duration,
smpi_cpu_threshold);
smpi_cfg_cpu_thresh());
}
}
......@@ -88,7 +84,7 @@ void smpi_execute_benched(double duration)
void smpi_bench_begin()
{
if (smpi_privatize_global_variables == SmpiPrivStrategies::MMAP) {
if (smpi_cfg_privatization() == SmpiPrivStrategies::MMAP) {
smpi_switch_data_segment(simgrid::s4u::Actor::self());
}
......@@ -96,7 +92,7 @@ void smpi_bench_begin()
return;
#if HAVE_PAPI
if (not simgrid::config::get_value<std::string>("smpi/papi-events").empty()) {
if (not smpi_cfg_papi_events_file().empty()) {
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() && PAPI_start(event_set) != PAPI_OK) {
......@@ -111,7 +107,7 @@ void smpi_bench_begin()
double smpi_adjust_comp_speed(){
double speedup=1;
if (simgrid::config::get_value<std::string>("smpi/comp-adjustment-file")[0] != '\0') {
if (smpi_cfg_comp_adjustment_file()[0] != '\0') {
smpi_trace_call_location_t* loc = smpi_process()->call_location();
std::string key = loc->get_composed_key();
......@@ -136,7 +132,7 @@ void smpi_bench_end()
* An MPI function has been called and now is the right time to update
* our PAPI counters for this process.
*/
if (not simgrid::config::get_value<std::string>("smpi/papi-events").empty()) {
if (not smpi_cfg_papi_events_file().empty()) {
papi_counter_t& counter_data = smpi_process()->papi_counters();
int event_set = smpi_process()->papi_event_set();
std::vector<long long> event_values = std::vector<long long>(counter_data.size());
......@@ -161,12 +157,12 @@ void smpi_bench_end()
// Maybe we need to artificially speed up or slow down our computation based on our statistical analysis.
// Simulate the benchmarked computation unless disabled via command-line argument
if (simgrid::config::get_value<bool>("smpi/simulate-computation")) {
if (smpi_cfg_simulate_computation()) {
smpi_execute(xbt_os_timer_elapsed(timer)/smpi_adjust_comp_speed());
}
#if HAVE_PAPI
if (not simgrid::config::get_value<std::string>("smpi/papi-events").empty() && TRACE_smpi_is_enabled()) {
if (not smpi_cfg_papi_events_file().empty() && TRACE_smpi_is_enabled()) {
container_t container =
simgrid::instr::Container::by_name(std::string("rank-") + std::to_string(simgrid::s4u::this_actor::get_pid()));
papi_counter_t& counter_data = smpi_process()->papi_counters();
......@@ -471,7 +467,7 @@ void smpi_trace_set_call_location(const char* file, const int line)
loc->previous_filename = loc->filename;
loc->previous_linenumber = loc->linenumber;
if(not simgrid::config::get_value<bool>("smpi/trace-call-use-absolute-path"))
if(not smpi_cfg_trace_call_use_absolute_path())
loc->filename = simgrid::xbt::Path(file).get_base_name();
else
loc->filename = file;
......
This diff is collapsed.
This diff is collapsed.
......@@ -489,7 +489,7 @@ void RecvAction::kernel(simgrid::xbt::ReplayAction&)
void ComputeAction::kernel(simgrid::xbt::ReplayAction&)
{
if (simgrid::config::get_value<bool>("smpi/simulate-computation")) {
if (smpi_cfg_simulate_computation()) {
smpi_execute_flops(args.flops/smpi_adjust_comp_speed());
}
}
......
......@@ -344,14 +344,14 @@ void* smpi_shared_malloc_partial(size_t size, size_t* shared_block_offsets, int
void *smpi_shared_malloc_intercept(size_t size, const char *file, int line) {
if( simgrid::config::get_value<double>("smpi/auto-shared-malloc-thresh") == 0 || size < simgrid::config::get_value<double>("smpi/auto-shared-malloc-thresh"))
if( smpi_cfg_auto_shared_malloc_thresh() == 0 || size < smpi_cfg_auto_shared_malloc_thresh())
return ::operator new(size);
else
return smpi_shared_malloc(size, file, line);
}
void* smpi_shared_calloc_intercept(size_t num_elm, size_t elem_size, const char* file, int line){
if( simgrid::config::get_value<double>("smpi/auto-shared-malloc-thresh") == 0 || elem_size*num_elm < simgrid::config::get_value<double>("smpi/auto-shared-malloc-thresh")){
if( smpi_cfg_auto_shared_malloc_thresh() == 0 || elem_size*num_elm < smpi_cfg_auto_shared_malloc_thresh()){
void* ptr = ::operator new(elem_size*num_elm);
memset(ptr, 0, elem_size*num_elm);
return ptr;
......@@ -361,9 +361,9 @@ void* smpi_shared_calloc_intercept(size_t num_elm, size_t elem_size, const char*
}
void *smpi_shared_malloc(size_t size, const char *file, int line) {
if (size > 0 && smpi_cfg_shared_malloc == SharedMallocType::LOCAL) {
if (size > 0 && smpi_cfg_shared_malloc() == SharedMallocType::LOCAL) {
return smpi_shared_malloc_local(size, file, line);
} else if (smpi_cfg_shared_malloc == SharedMallocType::GLOBAL) {
} else if (smpi_cfg_shared_malloc() == SharedMallocType::GLOBAL) {
int nb_shared_blocks = 1;
size_t shared_block_offsets[2] = {0, size};
return smpi_shared_malloc_partial(size, shared_block_offsets, nb_shared_blocks);
......@@ -376,7 +376,7 @@ int smpi_is_shared(const void* ptr, std::vector<std::pair<size_t, size_t>> &priv
private_blocks.clear(); // being paranoid
if (allocs_metadata.empty())
return 0;
if (smpi_cfg_shared_malloc == SharedMallocType::LOCAL || smpi_cfg_shared_malloc == SharedMallocType::GLOBAL) {
if (smpi_cfg_shared_malloc() == SharedMallocType::LOCAL || smpi_cfg_shared_malloc() == SharedMallocType::GLOBAL) {
auto low = allocs_metadata.lower_bound(ptr);
if (low != allocs_metadata.end() && low->first == ptr) {
private_blocks = low->second.private_blocks;
......@@ -440,7 +440,7 @@ std::vector<std::pair<size_t, size_t>> merge_private_blocks(const std::vector<st
void smpi_shared_free(void *ptr)
{
if (smpi_cfg_shared_malloc == SharedMallocType::LOCAL) {
if (smpi_cfg_shared_malloc() == SharedMallocType::LOCAL) {
char loc[PTR_STRLEN];
snprintf(loc, PTR_STRLEN, "%p", ptr);
auto meta = allocs_metadata.find(ptr);
......@@ -462,7 +462,7 @@ void smpi_shared_free(void *ptr)
XBT_DEBUG("Shared free - Local - no removal - of %p, count = %d", ptr, data->count);
}
} else if (smpi_cfg_shared_malloc == SharedMallocType::GLOBAL) {
} else if (smpi_cfg_shared_malloc() == SharedMallocType::GLOBAL) {
auto meta = allocs_metadata.find(ptr);
if (meta != allocs_metadata.end()){
meta->second.data->second.count--;
......
......@@ -66,7 +66,7 @@ void Comm::destroy(Comm* comm)
}
int Comm::dup(MPI_Comm* newcomm){
if (smpi_privatize_global_variables == SmpiPrivStrategies::MMAP) {
if (smpi_cfg_privatization() == SmpiPrivStrategies::MMAP) {
// we need to switch as the called function may silently touch global variables
smpi_switch_data_segment(s4u::Actor::self());
}
......@@ -380,7 +380,7 @@ void Comm::init_smp(){
smpi_process()->set_replaying(false);
}
if (smpi_privatize_global_variables == SmpiPrivStrategies::MMAP) {
if (smpi_cfg_privatization() == SmpiPrivStrategies::MMAP) {
// we need to switch as the called function may silently touch global variables
smpi_switch_data_segment(s4u::Actor::self());
}
......@@ -395,7 +395,7 @@ void Comm::init_smp(){
allgather__ring(&leader, 1, MPI_INT , leaders_map, 1, MPI_INT, this);
if (smpi_privatize_global_variables == SmpiPrivStrategies::MMAP) {
if (smpi_cfg_privatization() == SmpiPrivStrategies::MMAP) {
// we need to switch as the called function may silently touch global variables
smpi_switch_data_segment(s4u::Actor::self());
}
......@@ -468,7 +468,7 @@ void Comm::init_smp(){
}
bcast__scatter_LR_allgather(&(is_uniform_),1, MPI_INT, 0, comm_intra );
if (smpi_privatize_global_variables == SmpiPrivStrategies::MMAP) {
if (smpi_cfg_privatization() == SmpiPrivStrategies::MMAP) {
// we need to switch as the called function may silently touch global variables
smpi_switch_data_segment(s4u::Actor::self());
}
......
......@@ -275,7 +275,7 @@ int Datatype::copy(const void *sendbuf, int sendcount, MPI_Datatype sendtype,
// FIXME Handle the case of a partial shared malloc.
if (smpi_privatize_global_variables == SmpiPrivStrategies::MMAP) {
if (smpi_cfg_privatization() == SmpiPrivStrategies::MMAP) {
smpi_switch_data_segment(simgrid::s4u::Actor::self());
}
/* First check if we really have something to do */
......
......@@ -240,7 +240,7 @@ namespace smpi{
void Op::apply(const void* invec, void* inoutvec, const int* len, MPI_Datatype datatype)
{
if (smpi_privatize_global_variables == SmpiPrivStrategies::MMAP) {
if (smpi_cfg_privatization() == SmpiPrivStrategies::MMAP) {
// we need to switch as the called function may silently touch global variables
XBT_DEBUG("Applying operation, switch to the right data frame ");
smpi_switch_data_segment(simgrid::s4u::Actor::self());
......
......@@ -376,15 +376,13 @@ void Request::start()
simgrid::smpi::ActorExt* process = smpi_process_remote(simgrid::s4u::Actor::by_pid(dst_));
int async_small_thresh = simgrid::config::get_value<int>("smpi/async-small-thresh");
simgrid::s4u::MutexPtr mut = process->mailboxes_mutex();
if (async_small_thresh != 0 || (flags_ & MPI_REQ_RMA) != 0)
if (smpi_cfg_async_small_thresh() != 0 || (flags_ & MPI_REQ_RMA) != 0)
mut->lock();
if (async_small_thresh == 0 && (flags_ & MPI_REQ_RMA) == 0) {
if (smpi_cfg_async_small_thresh() == 0 && (flags_ & MPI_REQ_RMA) == 0) {
mailbox = process->mailbox();
} else if (((flags_ & MPI_REQ_RMA) != 0) || static_cast<int>(size_) < async_small_thresh) {
} else if (((flags_ & MPI_REQ_RMA) != 0) || static_cast<int>(size_) < smpi_cfg_async_small_thresh()) {
//We have to check both mailboxes (because SSEND messages are sent to the large mbox).
//begin with the more appropriate one : the small one.
mailbox = process->mailbox_small();
......@@ -423,7 +421,7 @@ void Request::start()
process->replaying() ? &smpi_comm_null_copy_buffer_callback : smpi_comm_copy_data_callback, this, -1.0);
XBT_DEBUG("recv simcall posted");
if (async_small_thresh != 0 || (flags_ & MPI_REQ_RMA) != 0)
if (smpi_cfg_async_small_thresh() != 0 || (flags_ & MPI_REQ_RMA) != 0)
mut->unlock();
} else { /* the RECV flag was not set, so this is a send */
simgrid::smpi::ActorExt* process = smpi_process_remote(simgrid::s4u::Actor::by_pid(dst_));
......@@ -437,7 +435,7 @@ void Request::start()
void* buf = buf_;
if ((flags_ & MPI_REQ_SSEND) == 0 &&
((flags_ & MPI_REQ_RMA) != 0 || (flags_ & MPI_REQ_BSEND) != 0 ||
static_cast<int>(size_) < simgrid::config::get_value<int>("smpi/send-is-detached-thresh"))) {
static_cast<int>(size_) < smpi_cfg_detached_send_thresh())) {
void *oldbuf = nullptr;
detached_ = true;
XBT_DEBUG("Send request %p is detached", this);
......@@ -445,7 +443,7 @@ void Request::start()
if (not(old_type_->flags() & DT_FLAG_DERIVED)) {
oldbuf = buf_;
if (not process->replaying() && oldbuf != nullptr && size_ != 0) {
if ((smpi_privatize_global_variables != SmpiPrivStrategies::NONE) &&
if ((smpi_cfg_privatization() != SmpiPrivStrategies::NONE) &&
(static_cast<char*>(buf_) >= smpi_data_exe_start) &&
(static_cast<char*>(buf_) < smpi_data_exe_start + smpi_data_exe_size)) {
XBT_DEBUG("Privatization : We are sending from a zone inside global memory. Switch data segment ");
......@@ -474,16 +472,14 @@ void Request::start()
XBT_DEBUG("sending size of %zu : sleep %f ", size_, sleeptime);
}
int async_small_thresh = simgrid::config::get_value<int>("smpi/async-small-thresh");
simgrid::s4u::MutexPtr mut = process->mailboxes_mutex();
if (async_small_thresh != 0 || (flags_ & MPI_REQ_RMA) != 0)
if (smpi_cfg_async_small_thresh() != 0 || (flags_ & MPI_REQ_RMA) != 0)
mut->lock();
if (not(async_small_thresh != 0 || (flags_ & MPI_REQ_RMA) != 0)) {
if (not(smpi_cfg_async_small_thresh() != 0 || (flags_ & MPI_REQ_RMA) != 0)) {
mailbox = process->mailbox();
} else if (((flags_ & MPI_REQ_RMA) != 0) || static_cast<int>(size_) < async_small_thresh) { // eager mode
} else if (((flags_ & MPI_REQ_RMA) != 0) || static_cast<int>(size_) < smpi_cfg_async_small_thresh()) { // eager mode
mailbox = process->mailbox();
XBT_DEBUG("Is there a corresponding recv already posted in the large mailbox %s?", mailbox->get_cname());
smx_activity_t action = mailbox->iprobe(1, &match_send, static_cast<void*>(this));
......@@ -526,7 +522,7 @@ void Request::start()
smpi_process()->get_tracing_category());
}
if (async_small_thresh != 0 || ((flags_ & MPI_REQ_RMA) != 0))
if (smpi_cfg_async_small_thresh() != 0 || ((flags_ & MPI_REQ_RMA) != 0))
mut->unlock();
}
}
......@@ -605,7 +601,7 @@ int Request::test(MPI_Request * request, MPI_Status * status, int* flag) {
nsleeps=1;//reset the number of sleeps we will do next time
if (*request != MPI_REQUEST_NULL && ((*request)->flags_ & MPI_REQ_PERSISTENT) == 0)
*request = MPI_REQUEST_NULL;
} else if (simgrid::config::get_value<bool>("smpi/grow-injected-times")) {
} else if (smpi_cfg_grow_injected_times()) {
nsleeps++;
}
}
......@@ -763,7 +759,7 @@ void Request::iprobe(int source, int tag, MPI_Comm comm, int* flag, MPI_Status*
// This can speed up the execution of certain applications by an order of magnitude, such as HPL
static int nsleeps = 1;
double speed = s4u::this_actor::get_host()->get_speed();
double maxrate = simgrid::config::get_value<double>("smpi/iprobe-cpu-usage");
double maxrate = smpi_cfg_iprobe_cpu_usage();
MPI_Request request = new Request(nullptr, 0, MPI_CHAR,
source == MPI_ANY_SOURCE ? MPI_ANY_SOURCE : comm->group()->actor(source)->get_pid(),
simgrid::s4u::this_actor::get_pid(), tag, comm, MPI_REQ_PERSISTENT | MPI_REQ_RECV);
......@@ -786,7 +782,7 @@ void Request::iprobe(int source, int tag, MPI_Comm comm, int* flag, MPI_Status*
request->print_request("New iprobe");
// We have to test both mailboxes as we don't know if we will receive one or another
if (simgrid::config::get_value<int>("smpi/async-small-thresh") > 0) {
if (smpi_cfg_async_small_thresh() > 0) {
mailbox = smpi_process()->mailbox_small();
XBT_DEBUG("Trying to probe the perm recv mailbox");
request->action_ = mailbox->iprobe(0, &match_recv, static_cast<void*>(request));
......@@ -812,7 +808,7 @@ void Request::iprobe(int source, int tag, MPI_Comm comm, int* flag, MPI_Status*
}
else {
*flag = 0;
if (simgrid::config::get_value<bool>("smpi/grow-injected-times"))
if (smpi_cfg_grow_injected_times())
nsleeps++;
}
unref(&request);
......@@ -851,7 +847,7 @@ void Request::finish_wait(MPI_Request* request, MPI_Status * status)
if (((req->flags_ & MPI_REQ_ACCUMULATE) != 0) ||
(datatype->flags() & DT_FLAG_DERIVED)) { // && (not smpi_is_shared(req->old_buf_))){
if (not smpi_process()->replaying() && smpi_privatize_global_variables != SmpiPrivStrategies::NONE &&
if (not smpi_process()->replaying() && smpi_cfg_privatization() != SmpiPrivStrategies::NONE &&
static_cast<char*>(req->old_buf_) >= smpi_data_exe_start &&
static_cast<char*>(req->old_buf_) < smpi_data_exe_start + smpi_data_exe_size) {
XBT_VERB("Privatization : We are unserializing to a zone in global memory Switch data segment ");
......
......@@ -100,6 +100,7 @@ set(SMPI_SRC
src/smpi/internals/smpi_replay.cpp
src/smpi/internals/smpi_actor.cpp
src/smpi/internals/smpi_utils.cpp
src/smpi/internals/smpi_config.cpp
src/smpi/mpi/smpi_comm.cpp
src/smpi/mpi/smpi_datatype.cpp
src/smpi/mpi/smpi_datatype_derived.cpp
......@@ -117,6 +118,7 @@ set(SMPI_SRC
src/smpi/include/smpi_actor.hpp
src/smpi/include/smpi_coll.hpp
src/smpi/include/smpi_comm.hpp
src/smpi/include/smpi_config.hpp
src/smpi/include/smpi_datatype_derived.hpp
src/smpi/include/smpi_datatype.hpp
src/smpi/include/smpi_errhandler.hpp
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment