static void print(std::vector<std::pair<size_t, size_t>> vec) {
std::fprintf(stderr, "{");
- for (auto elt : vec) {
+ for (auto const& elt : vec) {
std::fprintf(stderr, "(0x%zx, 0x%zx),", elt.first, elt.second);
}
std::fprintf(stderr, "}\n");
}
static void memcpy_private(void* dest, const void* src, std::vector<std::pair<size_t, size_t>>& private_blocks)
{
- for (auto block : private_blocks)
+ for (auto const& block : private_blocks)
memcpy((uint8_t*)dest+block.first, (uint8_t*)src+block.first, block.second-block.first);
}
static void check_blocks(std::vector<std::pair<size_t, size_t>> &private_blocks, size_t buff_size) {
- for (auto block : private_blocks)
+ for (auto const& block : private_blocks)
xbt_assert(block.first <= block.second && block.second <= buff_size, "Oops, bug in shared malloc.");
}
// Iterate over all the computational units. This could be processes, hosts, threads, ranks... You name it.
// I'm not exactly sure what we will support eventually, so I'll leave it at the general term "units".
- for (auto& unit_it : tokens) {
+ for (auto const& unit_it : tokens) {
boost::char_separator<char> separator_events(":");
Tokenizer event_tokens(unit_it, separator_events);
// Load the copy and resolve the entry point:
void* handle = dlopen(target_executable.c_str(), RTLD_LAZY | RTLD_LOCAL | RTLD_DEEPBIND);
+ int saved_errno = errno;
if (xbt_cfg_get_boolean("smpi/keep-temps") == false)
unlink(target_executable.c_str());
if (handle == nullptr)
- xbt_die("dlopen failed: %s (errno: %d -- %s)", dlerror(), errno, strerror(errno));
+ xbt_die("dlopen failed: %s (errno: %d -- %s)", dlerror(), saved_errno, strerror(saved_errno));
smpi_entry_point_type entry_point = smpi_resolve_function(handle);
if (not entry_point)
xbt_die("Could not resolve entry point");