From a900ac9d39fee1b3de240499c5326e5b8d4f44c2 Mon Sep 17 00:00:00 2001 From: Arnaud Giersch Date: Fri, 30 Mar 2018 22:16:44 +0200 Subject: [PATCH] Use enum class for smpi privatization strategies. --- src/mc/Session.cpp | 2 +- src/mc/remote/Client.cpp | 2 +- src/simix/smx_global.cpp | 2 +- src/smpi/include/private.hpp | 9 ++------- src/smpi/internals/smpi_bench.cpp | 2 +- src/smpi/internals/smpi_global.cpp | 27 ++++++++++++++------------- src/smpi/internals/smpi_memory.cpp | 6 +++--- src/smpi/internals/smpi_process.cpp | 2 +- src/smpi/mpi/smpi_comm.cpp | 12 ++++++++---- src/smpi/mpi/smpi_datatype.cpp | 2 +- src/smpi/mpi/smpi_op.cpp | 3 ++- src/smpi/mpi/smpi_request.cpp | 5 +++-- 12 files changed, 38 insertions(+), 36 deletions(-) diff --git a/src/mc/Session.cpp b/src/mc/Session.cpp index 97834f19a4..dcff662039 100644 --- a/src/mc/Session.cpp +++ b/src/mc/Session.cpp @@ -88,7 +88,7 @@ Session::Session(pid_t pid, int socket) { std::unique_ptr process(new simgrid::mc::RemoteClient(pid, socket)); // TODO, automatic detection of the config from the process - process->privatized(smpi_privatize_global_variables != SMPI_PRIVATIZE_NONE); + process->privatized(smpi_privatize_global_variables != SmpiPrivStrategies::None); modelChecker_ = std::unique_ptr( new simgrid::mc::ModelChecker(std::move(process))); xbt_assert(mc_model_checker == nullptr); diff --git a/src/mc/remote/Client.cpp b/src/mc/remote/Client.cpp index f515ae41e9..9c741c4a35 100644 --- a/src/mc/remote/Client.cpp +++ b/src/mc/remote/Client.cpp @@ -258,7 +258,7 @@ void Client::declareStack(void* stack, size_t size, smx_actor_t process, ucontex region.size = size; region.block = ((char*)stack - (char*)heap->heapbase) / BLOCKSIZE + 1; #if HAVE_SMPI - if (smpi_privatize_global_variables == SMPI_PRIVATIZE_MMAP && process) + if (smpi_privatize_global_variables == SmpiPrivStrategies::Mmap && process) region.process_index = process->pid - 1; else #endif diff --git a/src/simix/smx_global.cpp b/src/simix/smx_global.cpp index be1826fe62..6664cfa13a 100644 --- a/src/simix/smx_global.cpp +++ b/src/simix/smx_global.cpp @@ -103,7 +103,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 == SMPI_PRIVATIZE_NONE) { + if (smpi_enabled() && smpi_privatize_global_variables == SmpiPrivStrategies::None) { #if HAVE_PRIVATIZATION fprintf(stderr, "Try to enable SMPI variable privatization with --cfg=smpi/privatization:yes.\n"); #else diff --git a/src/smpi/include/private.hpp b/src/smpi/include/private.hpp index 7eebf7a743..b5edb7a452 100644 --- a/src/smpi/include/private.hpp +++ b/src/smpi/include/private.hpp @@ -437,13 +437,8 @@ extern "C" { XBT_PUBLIC smpi_trace_call_location_t* smpi_trace_get_call_location(); } -enum smpi_priv_strategies { - SMPI_PRIVATIZE_NONE = 0, - SMPI_PRIVATIZE_MMAP = 1, - SMPI_PRIVATIZE_DLOPEN = 2, - SMPI_PRIVATIZE_DEFAULT = SMPI_PRIVATIZE_DLOPEN -}; +enum class SmpiPrivStrategies { None = 0, Mmap = 1, Dlopen = 2, Default = Dlopen }; -extern XBT_PRIVATE int smpi_privatize_global_variables; +extern XBT_PRIVATE SmpiPrivStrategies smpi_privatize_global_variables; #endif diff --git a/src/smpi/internals/smpi_bench.cpp b/src/smpi/internals/smpi_bench.cpp index 5f8f451271..54736a67be 100644 --- a/src/smpi/internals/smpi_bench.cpp +++ b/src/smpi/internals/smpi_bench.cpp @@ -79,7 +79,7 @@ void smpi_execute_benched(double duration) void smpi_bench_begin() { - if (smpi_privatize_global_variables == SMPI_PRIVATIZE_MMAP) { + if (smpi_privatize_global_variables == SmpiPrivStrategies::Mmap) { smpi_switch_data_segment(simgrid::s4u::Actor::self()); } diff --git a/src/smpi/internals/smpi_global.cpp b/src/smpi/internals/smpi_global.cpp index b52f69a32e..99323b64c6 100644 --- a/src/smpi/internals/smpi_global.cpp +++ b/src/smpi/internals/smpi_global.cpp @@ -189,7 +189,8 @@ void smpi_comm_copy_buffer_callback(smx_activity_t synchro, void *buff, size_t b auto private_blocks = merge_private_blocks(src_private_blocks, dst_private_blocks); check_blocks(private_blocks, buff_size); void* tmpbuff=buff; - if ((smpi_privatize_global_variables == SMPI_PRIVATIZE_MMAP) && (static_cast(buff) >= smpi_data_exe_start) && + if ((smpi_privatize_global_variables == SmpiPrivStrategies::Mmap) && + (static_cast(buff) >= smpi_data_exe_start) && (static_cast(buff) < smpi_data_exe_start + smpi_data_exe_size)) { XBT_DEBUG("Privatization : We are copying from a zone inside global memory... Saving data to temp buffer !"); smpi_switch_data_segment(comm->src_proc->iface()); @@ -197,7 +198,7 @@ void smpi_comm_copy_buffer_callback(smx_activity_t synchro, void *buff, size_t b memcpy_private(tmpbuff, buff, private_blocks); } - if ((smpi_privatize_global_variables == SMPI_PRIVATIZE_MMAP) && ((char*)comm->dst_buff >= smpi_data_exe_start) && + if ((smpi_privatize_global_variables == SmpiPrivStrategies::Mmap) && ((char*)comm->dst_buff >= smpi_data_exe_start) && ((char*)comm->dst_buff < smpi_data_exe_start + smpi_data_exe_size)) { XBT_DEBUG("Privatization : We are copying to a zone inside global memory - Switch data segment"); smpi_switch_data_segment(comm->dst_proc->iface()); @@ -355,7 +356,7 @@ void smpi_global_destroy() xbt_os_timer_free(global_timer); } - if(smpi_privatize_global_variables == SMPI_PRIVATIZE_MMAP) + if (smpi_privatize_global_variables == SmpiPrivStrategies::Mmap) smpi_destroy_global_memory_segments(); smpi_free_static(); } @@ -371,21 +372,21 @@ static void smpi_init_options(){ xbt_assert(smpi_host_speed >= 0, "You're trying to set the host_speed to a negative value (%f)", smpi_host_speed); std::string smpi_privatize_option = xbt_cfg_get_string("smpi/privatization"); if (smpi_privatize_option == "no" || smpi_privatize_option == "0") - smpi_privatize_global_variables = SMPI_PRIVATIZE_NONE; + smpi_privatize_global_variables = SmpiPrivStrategies::None; else if (smpi_privatize_option == "yes" || smpi_privatize_option == "1") - smpi_privatize_global_variables = SMPI_PRIVATIZE_DEFAULT; + smpi_privatize_global_variables = SmpiPrivStrategies::Default; else if (smpi_privatize_option == "mmap") - smpi_privatize_global_variables = SMPI_PRIVATIZE_MMAP; + smpi_privatize_global_variables = SmpiPrivStrategies::Mmap; else if (smpi_privatize_option == "dlopen") - smpi_privatize_global_variables = SMPI_PRIVATIZE_DLOPEN; + smpi_privatize_global_variables = SmpiPrivStrategies::Dlopen; else xbt_die("Invalid value for smpi/privatization: '%s'", smpi_privatize_option.c_str()); #if defined(__FreeBSD__) - if (smpi_privatize_global_variables == SMPI_PRIVATIZE_MMAP) { - XBT_INFO("mmap privatization is broken on FreeBSD, switching to dlopen privatization instead."); - smpi_privatize_global_variables = SMPI_PRIVATIZE_DLOPEN; - } + if (smpi_privatize_global_variables == SmpiPrivStrategies::Mmap) { + XBT_INFO("mmap privatization is broken on FreeBSD, switching to dlopen privatization instead."); + smpi_privatize_global_variables = SmpiPrivStrategies::Dlopen; + } #endif if (smpi_cpu_threshold < 0) @@ -475,7 +476,7 @@ int smpi_main(const char* executable, int argc, char *argv[]) SIMIX_comm_set_copy_data_callback(smpi_comm_copy_buffer_callback); smpi_init_options(); - if (smpi_privatize_global_variables == SMPI_PRIVATIZE_DLOPEN) { + if (smpi_privatize_global_variables == SmpiPrivStrategies::Dlopen) { std::string executable_copy = executable; @@ -619,7 +620,7 @@ void SMPI_init(){ smpi_check_options(); TRACE_smpi_alloc(); simgrid::s4u::onSimulationEnd.connect(TRACE_smpi_release); - if(smpi_privatize_global_variables == SMPI_PRIVATIZE_MMAP) + if (smpi_privatize_global_variables == SmpiPrivStrategies::Mmap) smpi_backup_global_memory_segment(); } diff --git a/src/smpi/internals/smpi_memory.cpp b/src/smpi/internals/smpi_memory.cpp index e70482319a..a6ea8dd78f 100644 --- a/src/smpi/internals/smpi_memory.cpp +++ b/src/smpi/internals/smpi_memory.cpp @@ -30,7 +30,7 @@ XBT_LOG_NEW_DEFAULT_SUBCATEGORY(smpi_memory, smpi, "Memory layout support for SM int smpi_loaded_page = -1; char* smpi_data_exe_start = nullptr; int smpi_data_exe_size = 0; -int smpi_privatize_global_variables; +SmpiPrivStrategies smpi_privatize_global_variables; static void* smpi_data_exe_copy; // We keep a copy of all the privatization regions: We can then delete everything easily by iterating over this @@ -148,7 +148,7 @@ void smpi_backup_global_memory_segment() XBT_DEBUG("bss+data segment found : size %d starting at %p", smpi_data_exe_size, smpi_data_exe_start); if (smpi_data_exe_size == 0) { // no need to do anything as global variables don't exist - smpi_privatize_global_variables=false; + smpi_privatize_global_variables = SmpiPrivStrategies::None; return; } @@ -157,7 +157,7 @@ void smpi_backup_global_memory_segment() // of the simulation and can be used to initialize a dynamically added, new process. asan_safe_memcpy(smpi_data_exe_copy, TOPAGE(smpi_data_exe_start), smpi_data_exe_size); #else /* ! HAVE_PRIVATIZATION */ - smpi_privatize_global_variables = false; + smpi_privatize_global_variables = SmpiPrivStrategies::None; xbt_die("You are trying to use privatization on a system that does not support it. Don't."); return; #endif diff --git a/src/smpi/internals/smpi_process.cpp b/src/smpi/internals/smpi_process.cpp index dc1c516a1b..b4f2dd887d 100644 --- a/src/smpi/internals/smpi_process.cpp +++ b/src/smpi/internals/smpi_process.cpp @@ -262,7 +262,7 @@ void Process::init(int *argc, char ***argv){ // cheinrich: I'm not sure what the impact of the SMPI_switch_data_segment on this call is. I moved // this up here so that I can set the privatized region before the switch. Process* process = smpi_process_remote(proc); - if(smpi_privatize_global_variables == SMPI_PRIVATIZE_MMAP){ + if (smpi_privatize_global_variables == SmpiPrivStrategies::Mmap) { /* Now using the segment index of this process */ process->set_privatized_region(smpi_init_global_memory_segment_process()); /* Done at the process's creation */ diff --git a/src/smpi/mpi/smpi_comm.cpp b/src/smpi/mpi/smpi_comm.cpp index c256f12d46..1183cacffb 100644 --- a/src/smpi/mpi/smpi_comm.cpp +++ b/src/smpi/mpi/smpi_comm.cpp @@ -56,7 +56,8 @@ void Comm::destroy(Comm* comm) } int Comm::dup(MPI_Comm* newcomm){ - if(smpi_privatize_global_variables == SMPI_PRIVATIZE_MMAP){ //we need to switch as the called function may silently touch global variables + if (smpi_privatize_global_variables == SmpiPrivStrategies::Mmap) { + // we need to switch as the called function may silently touch global variables smpi_switch_data_segment(simgrid::s4u::Actor::self()); } MPI_Group cp = new Group(this->group()); @@ -299,7 +300,8 @@ void Comm::init_smp(){ smpi_process()->set_replaying(false); } - if(smpi_privatize_global_variables == SMPI_PRIVATIZE_MMAP){ //we need to switch as the called function may silently touch global variables + if (smpi_privatize_global_variables == SmpiPrivStrategies::Mmap) { + // we need to switch as the called function may silently touch global variables smpi_switch_data_segment(simgrid::s4u::Actor::self()); } //identify neighbours in comm @@ -335,7 +337,8 @@ void Comm::init_smp(){ Coll_allgather_mpich::allgather(&leader, 1, MPI_INT , leaders_map, 1, MPI_INT, this); - if(smpi_privatize_global_variables == SMPI_PRIVATIZE_MMAP){ //we need to switch as the called function may silently touch global variables + if (smpi_privatize_global_variables == SmpiPrivStrategies::Mmap) { + // we need to switch as the called function may silently touch global variables smpi_switch_data_segment(simgrid::s4u::Actor::self()); } @@ -407,7 +410,8 @@ void Comm::init_smp(){ } Coll_bcast_mpich::bcast(&(is_uniform_),1, MPI_INT, 0, comm_intra ); - if(smpi_privatize_global_variables == SMPI_PRIVATIZE_MMAP){ //we need to switch as the called function may silently touch global variables + if (smpi_privatize_global_variables == SmpiPrivStrategies::Mmap) { + // we need to switch as the called function may silently touch global variables smpi_switch_data_segment(simgrid::s4u::Actor::self()); } // Are the ranks blocked ? = allocated contiguously on the SMP nodes diff --git a/src/smpi/mpi/smpi_datatype.cpp b/src/smpi/mpi/smpi_datatype.cpp index de11260b77..a17f42eba4 100644 --- a/src/smpi/mpi/smpi_datatype.cpp +++ b/src/smpi/mpi/smpi_datatype.cpp @@ -294,7 +294,7 @@ int Datatype::copy(void *sendbuf, int sendcount, MPI_Datatype sendtype, // FIXME Handle the case of a partial shared malloc. - if(smpi_privatize_global_variables == SMPI_PRIVATIZE_MMAP){ + if (smpi_privatize_global_variables == SmpiPrivStrategies::Mmap) { smpi_switch_data_segment(simgrid::s4u::Actor::self()); } /* First check if we really have something to do */ diff --git a/src/smpi/mpi/smpi_op.cpp b/src/smpi/mpi/smpi_op.cpp index 521f9b0dca..0cc66590c4 100644 --- a/src/smpi/mpi/smpi_op.cpp +++ b/src/smpi/mpi/smpi_op.cpp @@ -240,7 +240,8 @@ void Op::set_fortran_op() void Op::apply(void *invec, void *inoutvec, int *len, MPI_Datatype datatype) { - if(smpi_privatize_global_variables == SMPI_PRIVATIZE_MMAP){//we need to switch as the called function may silently touch global variables + if (smpi_privatize_global_variables == 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()); } diff --git a/src/smpi/mpi/smpi_request.cpp b/src/smpi/mpi/smpi_request.cpp index cff18d4fc7..b2e9be671e 100644 --- a/src/smpi/mpi/smpi_request.cpp +++ b/src/smpi/mpi/smpi_request.cpp @@ -410,7 +410,8 @@ 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 != 0) && (static_cast(buf_) >= smpi_data_exe_start) && + if ((smpi_privatize_global_variables != SmpiPrivStrategies::None) && + (static_cast(buf_) >= smpi_data_exe_start) && (static_cast(buf_) < smpi_data_exe_start + smpi_data_exe_size)) { XBT_DEBUG("Privatization : We are sending from a zone inside global memory. Switch data segment "); smpi_switch_data_segment(simgrid::s4u::Actor::byPid(src_)); @@ -704,7 +705,7 @@ void Request::finish_wait(MPI_Request* request, MPI_Status * status) if (((req->flags_ & ACCUMULATE) != 0) || (datatype->flags() & DT_FLAG_DERIVED)) { // && (not smpi_is_shared(req->old_buf_))){ - if (not smpi_process()->replaying() && smpi_privatize_global_variables != 0 && + if (not smpi_process()->replaying() && smpi_privatize_global_variables != SmpiPrivStrategies::None && static_cast(req->old_buf_) >= smpi_data_exe_start && static_cast(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 "); -- 2.20.1