-/* Copyright (c) 2015-2017. The SimGrid Team. All rights reserved. */
+/* Copyright (c) 2015-2018. 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 <cstdint>
-#include <climits>
-#include <cstring>
-
-#include <vector>
-
#include <cerrno>
+#include <climits>
+#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
+#include <deque>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
+#include <vector>
#ifndef WIN32
#include <sys/mman.h>
int smpi_loaded_page = -1;
char* smpi_data_exe_start = nullptr;
int smpi_data_exe_size = 0;
-int smpi_privatize_global_variables;
-static char* smpi_data_exe_copy;
+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
// collection and nothing can be leaked. We could also iterate over all actors but we would have to be diligent when two
// actors use the same privatization region (so, smart pointers would have to be used etc.)
-static std::set<smpi_privatization_region_t> smpi_privatization_regions;
+// Use a std::deque so that pointers remain valid after push_back().
+static std::deque<s_smpi_privatization_region_t> smpi_privatization_regions;
static const int PROT_RWX = (PROT_READ | PROT_WRITE | PROT_EXEC);
static const int PROT_RW = (PROT_READ | PROT_WRITE );
#endif
/** 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, we've already loaded the one we want
+void smpi_switch_data_segment(simgrid::s4u::ActorPtr actor)
+{
+ if (smpi_loaded_page == actor->get_pid()) // no need to switch, we've already loaded the one we want
return;
// So the job:
- smpi_really_switch_data_segment(dest);
+ smpi_really_switch_data_segment(actor);
}
/** 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)
+void smpi_really_switch_data_segment(simgrid::s4u::ActorPtr actor)
{
if (smpi_data_exe_size == 0) // no need to switch
return;
#if HAVE_PRIVATIZATION
// FIXME, cross-process support (mmap across process when necessary)
- simgrid::smpi::Process* process = smpi_process_remote(dest);
+ XBT_DEBUG("Switching data frame to the one of process %ld", actor->get_pid());
+ simgrid::smpi::Process* process = smpi_process_remote(actor);
int current = process->privatized_region()->file_descriptor;
- XBT_DEBUG("Switching data frame to the one of process %d", dest);
void* tmp =
mmap(TOPAGE(smpi_data_exe_start), smpi_data_exe_size, PROT_READ | PROT_WRITE, MAP_FIXED | MAP_SHARED, current, 0);
if (tmp != TOPAGE(smpi_data_exe_start))
xbt_die("Couldn't map the new region (errno %d): %s", errno, strerror(errno));
- smpi_loaded_page = dest;
+ smpi_loaded_page = actor->get_pid();
#endif
}
return buffer_path.compare(0, std::string::npos, file, buffer_path.length()) == 0;
}
-// TODO: cheinrich: The behavior changed; this now only makes a backup of the
-// data segment. I think the function should be renamed.
+/**
+ * @brief Makes a backup of the segment in memory that stores the global variables of a process.
+ * This backup is then used to initialize the global variables for every single
+ * process that is added, regardless of the progress of the simulation.
+ */
void smpi_backup_global_memory_segment()
{
-#if HAVE_PRIVATIZATION
+ xbt_assert(HAVE_PRIVATIZATION, "You are trying to use privatization on a system that does not support it. Don't.");
smpi_get_executable_global_size();
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;
}
- smpi_data_exe_copy = (char*)malloc(smpi_data_exe_size);
+ smpi_data_exe_copy = ::operator new(smpi_data_exe_size);
// Make a copy of the data segment. This clean copy is retained over the whole runtime
// 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;
- xbt_die("You are trying to use privatization on a system that does not support it. Don't.");
- return;
-#endif
}
// Initializes the memory mapping for a single process and returns the privatization region
asan_safe_memcpy(address, smpi_data_exe_copy, smpi_data_exe_size);
// store the address of the mapping for further switches
- smpi_privatization_region_t tmp =
- static_cast<smpi_privatization_region_t>(new struct s_smpi_privatization_region_t);
+ smpi_privatization_regions.emplace_back(s_smpi_privatization_region_t{address, file_descriptor});
- tmp->file_descriptor = file_descriptor;
- tmp->address = address;
- smpi_privatization_regions.insert(tmp);
-
- return tmp;
+ return &smpi_privatization_regions.back();
}
void smpi_destroy_global_memory_segments(){
if (smpi_data_exe_size == 0) // no need to switch
return;
#if HAVE_PRIVATIZATION
- for (auto& it : smpi_privatization_regions) {
- if (munmap(it->address, smpi_data_exe_size) < 0)
- XBT_WARN("Unmapping of fd %d failed: %s", it->file_descriptor, strerror(errno));
- close(it->file_descriptor);
+ for (auto const& region : smpi_privatization_regions) {
+ if (munmap(region.address, smpi_data_exe_size) < 0)
+ XBT_WARN("Unmapping of fd %d failed: %s", region.file_descriptor, strerror(errno));
+ close(region.file_descriptor);
}
+ smpi_privatization_regions.clear();
+ ::operator delete(smpi_data_exe_copy);
#endif
}
+static int sendbuffer_size = 0;
+static char* sendbuffer = nullptr;
+static int recvbuffer_size = 0;
+static char* recvbuffer = nullptr;
+
+//allocate a single buffer for all sends, growing it if needed
+void* smpi_get_tmp_sendbuffer(int size)
+{
+ if (not smpi_process()->replaying())
+ return xbt_malloc(size);
+ if (sendbuffer_size<size){
+ sendbuffer=static_cast<char*>(xbt_realloc(sendbuffer,size));
+ sendbuffer_size=size;
+ }
+ return sendbuffer;
+}
+
+//allocate a single buffer for all recv
+void* smpi_get_tmp_recvbuffer(int size){
+ if (not smpi_process()->replaying())
+ return xbt_malloc(size);
+ if (recvbuffer_size<size){
+ recvbuffer=static_cast<char*>(xbt_realloc(recvbuffer,size));
+ recvbuffer_size=size;
+ }
+ return recvbuffer;
+}
+
+void smpi_free_tmp_buffer(void* buf){
+ if (not smpi_process()->replaying())
+ xbt_free(buf);
+}
+
+void smpi_free_replay_tmp_buffers(){
+ xbt_free(sendbuffer);
+ xbt_free(recvbuffer);
+}
