A call to bprintf is enough here.

[simgrid.git] / src / smpi / internals / smpi_shared.cpp

diff --git a/src/smpi/internals/smpi_shared.cpp b/src/smpi/internals/smpi_shared.cpp
index 27bd066..728b97a 100644 (file)
--- a/src/smpi/internals/smpi_shared.cpp
+++ b/src/smpi/internals/smpi_shared.cpp
@@ -66,58 +66,28 @@ namespace{
  *  This information is used by SMPI_SHARED_MALLOC to allocate  some shared memory for all simulated processes.
  */
 
-class smpi_source_location {
+class smpi_source_location : public std::string {
 public:
-  smpi_source_location(const char* filename, int line)
-      : filename(xbt_strdup(filename)), filename_length(strlen(filename)), line(line)
+  smpi_source_location(const char* filename, int line) : std::string(std::string(filename) + ":" + std::to_string(line))
   {
   }
-
-  /** Pointer to a static string containing the file name */
-  char* filename      = nullptr;
-  int filename_length = 0;
-  int line            = 0;
-
-  bool operator==(smpi_source_location const& that) const
-  {
-    return filename_length == that.filename_length && line == that.line &&
-           std::memcmp(filename, that.filename, filename_length) == 0;
-  }
-  bool operator!=(smpi_source_location const& that) const { return not(*this == that); }
-};
-}
-
-namespace std {
-
-template <> class hash<smpi_source_location> {
-public:
-  typedef smpi_source_location argument_type;
-  typedef std::size_t result_type;
-  result_type operator()(smpi_source_location const& loc) const
-  {
-    return xbt_str_hash_ext(loc.filename, loc.filename_length) ^
-           xbt_str_hash_ext((const char*)&loc.line, sizeof(loc.line));
-  }
 };
-}
 
-namespace{
-
-typedef struct {
+struct shared_data_t {
   int fd    = -1;
   int count = 0;
-} shared_data_t;
+};
 
-std::unordered_map<smpi_source_location, shared_data_t> allocs;
-typedef std::unordered_map<smpi_source_location, shared_data_t>::value_type shared_data_key_type;
+std::unordered_map<smpi_source_location, shared_data_t, std::hash<std::string>> allocs;
+typedef decltype(allocs)::value_type shared_data_key_type;
 
-typedef struct {
+struct shared_metadata_t {
   size_t size;
   size_t allocated_size;
   void *allocated_ptr;
   std::vector<std::pair<size_t, size_t>> private_blocks;
   shared_data_key_type* data;
-} shared_metadata_t;
+};
 
 std::map<void*, shared_metadata_t> allocs_metadata;
 std::map<std::string, void*> calls;
@@ -262,8 +232,7 @@ void* smpi_shared_malloc_partial(size_t size, size_t* shared_block_offsets, int
    * We cannot use a same file for the two type of calls, since the first one needs to be
    * opened in a hugetlbfs mount point whereas the second needs to be a "classical" file. */
   if(use_huge_page && smpi_shared_malloc_bogusfile_huge_page == -1) {
-    const char *const array[] = {huge_page_mount_point, "simgrid-shmalloc-XXXXXX", nullptr};
-    char *huge_page_filename = xbt_str_join_array(array, "/");
+    char* huge_page_filename               = bprintf("%s/simgrid-shmalloc-XXXXXX", huge_page_mount_point);
     smpi_shared_malloc_bogusfile_huge_page = mkstemp(huge_page_filename);
     XBT_DEBUG("bogusfile_huge_page: %s\n", huge_page_filename);
     unlink(huge_page_filename);
@@ -388,7 +357,7 @@ int smpi_is_shared(void* ptr, std::vector<std::pair<size_t, size_t>> &private_bl
     return 0;
   if ( smpi_cfg_shared_malloc == shmalloc_local || smpi_cfg_shared_malloc == shmalloc_global) {
     auto low = allocs_metadata.lower_bound(ptr);
-    if (low->first==ptr) {
+    if (low != allocs_metadata.end() && low->first == ptr) {
       private_blocks = low->second.private_blocks;
       *offset = 0;
       return 1;
@@ -410,11 +379,11 @@ int smpi_is_shared(void* ptr, std::vector<std::pair<size_t, size_t>> &private_bl
 
 std::vector<std::pair<size_t, size_t>> shift_and_frame_private_blocks(const std::vector<std::pair<size_t, size_t>> vec, size_t offset, size_t buff_size) {
     std::vector<std::pair<size_t, size_t>> result;
-    for(auto block: vec) {
-        auto new_block = std::make_pair(std::min(std::max((size_t)0, block.first-offset), buff_size),
-                                        std::min(std::max((size_t)0, block.second-offset), buff_size));
-        if(new_block.second > 0 && new_block.first < buff_size)
-            result.push_back(new_block);
+    for (auto const& block : vec) {
+      auto new_block = std::make_pair(std::min(std::max((size_t)0, block.first - offset), buff_size),
+                                      std::min(std::max((size_t)0, block.second - offset), buff_size));
+      if (new_block.second > 0 && new_block.first < buff_size)
+        result.push_back(new_block);
     }
     return result;
 }