X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/76af4f8d5d8f11687e093dd5f2c7f94c16e51387..78d426efd0d78380e29df1c1496897d2bc62f596:/src/smpi/internals/smpi_utils.cpp diff --git a/src/smpi/internals/smpi_utils.cpp b/src/smpi/internals/smpi_utils.cpp index 16fe5b5cff..09688d88f2 100644 --- a/src/smpi/internals/smpi_utils.cpp +++ b/src/smpi/internals/smpi_utils.cpp @@ -1,5 +1,4 @@ -/* Copyright (c) 2016-2021. The SimGrid Team. - * All rights reserved. */ +/* Copyright (c) 2016-2023. 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. */ @@ -8,22 +7,19 @@ #include "private.hpp" #include "smpi_config.hpp" -#include "src/surf/xml/platf.hpp" +#include "src/kernel/xml/platf.hpp" +#include "xbt/ex.h" #include "xbt/file.hpp" #include "xbt/log.h" #include "xbt/parse_units.hpp" +#include "xbt/str.h" #include "xbt/sysdep.h" #include #include XBT_LOG_NEW_DEFAULT_SUBCATEGORY(smpi_utils, smpi, "Logging specific to SMPI (utils)"); -extern std::string surf_parsed_filename; -extern int surf_parse_lineno; - -namespace simgrid { -namespace smpi { -namespace utils { +namespace { double total_benched_time=0; unsigned long total_malloc_size=0; @@ -42,75 +38,23 @@ struct current_buffer_metadata_t { }; alloc_metadata_t max_malloc; -F2C* current_handle = nullptr; +simgrid::smpi::F2C* current_handle = nullptr; current_buffer_metadata_t current_buffer1; current_buffer_metadata_t current_buffer2; std::unordered_map allocs; -std::vector parse_factor(const std::string& smpi_coef_string) -{ - std::vector smpi_factor; - - /** Setup the tokenizer that parses the string **/ - using Tokenizer = boost::tokenizer>; - boost::char_separator sep(";"); - boost::char_separator factor_separator(":"); - Tokenizer tokens(smpi_coef_string, sep); - - /** - * Iterate over patterns like A:B:C:D;E:F;G:H - * These will be broken down into: - * A --> B, C, D - * E --> F - * G --> H - */ - for (auto token_iter = tokens.begin(); token_iter != tokens.end(); ++token_iter) { - XBT_DEBUG("token: %s", token_iter->c_str()); - Tokenizer factor_values(*token_iter, factor_separator); - s_smpi_factor_t fact; - xbt_assert(factor_values.begin() != factor_values.end(), "Malformed radical for smpi factor: '%s'", - smpi_coef_string.c_str()); - unsigned int iteration = 0; - for (auto factor_iter = factor_values.begin(); factor_iter != factor_values.end(); ++factor_iter) { - iteration++; - - if (factor_iter == factor_values.begin()) { /* first element */ - try { - fact.factor = std::stoi(*factor_iter); - } catch (const std::invalid_argument&) { - throw std::invalid_argument(std::string("Invalid factor in chunk ") + std::to_string(smpi_factor.size() + 1) + - ": " + *factor_iter); - } - } else { - try { - fact.values.push_back(xbt_parse_get_time(surf_parsed_filename, surf_parse_lineno, *factor_iter, "")); - } catch (const std::invalid_argument&) { - throw std::invalid_argument(std::string("Invalid factor value ") + std::to_string(iteration) + " in chunk " + - std::to_string(smpi_factor.size() + 1) + ": " + *factor_iter); - } - } - } +std::unordered_map> collective_calls; - smpi_factor.push_back(fact); - XBT_DEBUG("smpi_factor:\t%zu: %zu values, first: %f", fact.factor, smpi_factor.size(), fact.values[0]); - } - std::sort(smpi_factor.begin(), smpi_factor.end(), [](const s_smpi_factor_t &pa, const s_smpi_factor_t &pb) { - return (pa.factor < pb.factor); - }); - for (auto const& fact : smpi_factor) { - XBT_DEBUG("smpi_factor:\t%zu: %zu values, first: %f", fact.factor, smpi_factor.size(), fact.values[0]); - } - smpi_factor.shrink_to_fit(); +} // namespace - return smpi_factor; -} +namespace simgrid::smpi::utils { void add_benched_time(double time){ total_benched_time += time; } -void account_malloc_size(size_t size, const std::string& file, int line, void* ptr) +void account_malloc_size(size_t size, std::string_view file, int line, const void* ptr) { if (smpi_cfg_display_alloc()) { alloc_metadata_t metadata; @@ -118,7 +62,7 @@ void account_malloc_size(size_t size, const std::string& file, int line, void* p metadata.line = line; metadata.numcall = 1; metadata.file = file; - allocs.emplace(ptr, metadata); + allocs.try_emplace(ptr, metadata); total_malloc_size += size; if(size > max_malloc.size){ @@ -175,25 +119,24 @@ static void print_leaked_handles() // freed at this point bool display_advice = false; std::map> count; - for (const auto& elem : handles) { - std::string key = elem.second->name(); - if ((not xbt_log_no_loc) && (not elem.second->call_location().empty())) - key += " at " + elem.second->call_location(); + for (const auto& [_, elem] : handles) { + std::string key = elem->name(); + if ((not xbt_log_no_loc) && (not elem->call_location().empty())) + key += " at " + elem->call_location(); else display_advice = true; - auto result = count.emplace(key, 1); - if (result.second == false) - result.first->second++; + auto& result = count.try_emplace(key, 0).first->second; + result++; } if (display_advice) XBT_WARN("To get more information (location of allocations), compile your code with -trace-call-location flag of " "smpicc/f90"); unsigned int i = 0; - for (const auto& p : count) { - if (p.second == 1) - XBT_INFO("leaked handle of type %s", p.first.c_str()); + for (const auto& [key, value] : count) { + if (value == 1) + XBT_INFO("leaked handle of type %s", key.c_str()); else - XBT_INFO("%d leaked handles of type %s", p.second, p.first.c_str()); + XBT_INFO("%d leaked handles of type %s", value, key.c_str()); i++; if (i == max) break; @@ -225,19 +168,17 @@ static void print_leaked_buffers() size_t max_size; }; std::map> leaks_aggreg; - for (const auto& elem : allocs) { + for (const auto& [_, elem] : allocs) { std::string key = "leaked allocations"; if (not xbt_log_no_loc) - key = elem.second.file + ":" + std::to_string(elem.second.line) + ": " + key; - auto result = leaks_aggreg.emplace(key, buff_leak{1, elem.second.size, elem.second.size, elem.second.size}); - if (result.second == false) { - result.first->second.count++; - result.first->second.total_size += elem.second.size; - if (elem.second.size > result.first->second.max_size) - result.first->second.max_size = elem.second.size; - else if (elem.second.size < result.first->second.min_size) - result.first->second.min_size = elem.second.size; - } + key = elem.file + ":" + std::to_string(elem.line) + ": " + key; + auto& result = leaks_aggreg.try_emplace(key, buff_leak{0, 0, elem.size, elem.size}).first->second; + result.count++; + result.total_size += elem.size; + if (elem.size > result.max_size) + result.max_size = elem.size; + else if (elem.size < result.min_size) + result.min_size = elem.size; } // now we can order by total size. std::vector> leaks(leaks_aggreg.begin(), leaks_aggreg.end()); @@ -245,13 +186,13 @@ static void print_leaked_buffers() [](auto const& a, auto const& b) { return a.second.total_size > b.second.total_size; }); unsigned int i = 0; - for (const auto& p : leaks) { - if (p.second.min_size == p.second.max_size) - XBT_INFO("%s of total size %zu, called %d times, each with size %zu", p.first.c_str(), p.second.total_size, - p.second.count, p.second.min_size); + for (const auto& [key, value] : leaks) { + if (value.min_size == value.max_size) + XBT_INFO("%s of total size %zu, called %d times, each with size %zu", key.c_str(), value.total_size, value.count, + value.min_size); else - XBT_INFO("%s of total size %zu, called %d times, with minimum size %zu and maximum size %zu", p.first.c_str(), - p.second.total_size, p.second.count, p.second.min_size, p.second.max_size); + XBT_INFO("%s of total size %zu, called %d times, with minimum size %zu and maximum size %zu", key.c_str(), + value.total_size, value.count, value.min_size, value.max_size); i++; if (i == max) break; @@ -320,11 +261,14 @@ void set_current_buffer(int i, const char* name, const void* buf){ } } -void print_buffer_info(){ - if(not current_buffer1.name.empty()) - XBT_INFO("Buffer %s was allocated from %s line %d, with size %zu", current_buffer1.name.c_str(), current_buffer1.alloc.file.c_str(), current_buffer1.alloc.line, current_buffer1.alloc.size); - if(not current_buffer2.name.empty()) - XBT_INFO("Buffer %s was allocated from %s line %d, with size %zu", current_buffer2.name.c_str(), current_buffer2.alloc.file.c_str(), current_buffer2.alloc.line, current_buffer2.alloc.size); +void print_buffer_info() +{ + if (not current_buffer1.name.empty()) + XBT_INFO("Buffer %s was allocated from %s line %d, with size %zu", current_buffer1.name.c_str(), + current_buffer1.alloc.file.c_str(), current_buffer1.alloc.line, current_buffer1.alloc.size); + if (not current_buffer2.name.empty()) + XBT_INFO("Buffer %s was allocated from %s line %d, with size %zu", current_buffer2.name.c_str(), + current_buffer2.alloc.file.c_str(), current_buffer2.alloc.line, current_buffer2.alloc.size); } size_t get_buffer_size(const void* buf){ @@ -342,6 +286,26 @@ void account_free(const void* ptr){ } } +int check_collectives_ordering(MPI_Comm comm, const std::string& call) +{ + unsigned int count = comm->get_collectives_count(); + comm->increment_collectives_count(); + if (auto vec = collective_calls.find(comm->id()); vec == collective_calls.end()) { + collective_calls.try_emplace(comm->id(), std::vector{call}); + } else { + // are we the first ? add the call + if (vec->second.size() == count) { + vec->second.emplace_back(call); + } else if (vec->second.size() > count) { + if (vec->second[count] != call) { + XBT_WARN("Collective operation mismatch. For process %ld, expected %s, got %s", + simgrid::s4u::this_actor::get_pid(), vec->second[count].c_str(), call.c_str()); + return MPI_ERR_OTHER; + } + } else { + THROW_IMPOSSIBLE; + } + } + return MPI_SUCCESS; } -} -} // namespace simgrid +} // namespace simgrid::smpi::utils