* Associated data and metadata are used as follows:
*
* mmap #1
- * `allocs' dict ---- -.
+ * `allocs' map ---- -.
* ---------- shared_data_t shared_metadata_t / | | |
* .->| <name> | ---> -------------------- <--. ----------------- | | | |
* | ---------- | fd of <name> | | | size of mmap | --| | | |
* `----------------- | <name> | | ----------------- ---- |
* -------------------- | ^ |
* | | |
- * | | `allocs_metadata' dict |
+ * | | `allocs_metadata' map |
* | | ---------------------- |
* | `-- | <addr of mmap #1> |<-'
* | .-- | <addr of mmap #2> |<-.
#include "private.h"
#include "private.hpp"
-#include "xbt/dict.h"
-#include "xbt/ex.hpp"
-#include <errno.h>
+#include <cerrno>
#include <sys/types.h>
#ifndef WIN32
#include <sys/mman.h>
#endif
-#include <sys/stat.h>
+#include <cstdio>
#include <fcntl.h>
-#include <string.h>
-#include <stdio.h>
+#include <sys/stat.h>
#ifndef MAP_ANONYMOUS
#define MAP_ANONYMOUS MAP_ANON
* This information is used by SMPI_SHARED_MALLOC to allocate some shared memory for all simulated processes.
*/
-class smpi_source_location {
-public:
- smpi_source_location(const char* filename, int line)
- : filename(xbt_strdup(filename)), filename_length(strlen(filename)), line(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> {
+class smpi_source_location : public std::string {
public:
- typedef smpi_source_location argument_type;
- typedef std::size_t result_type;
- result_type operator()(smpi_source_location const& loc) const
+ smpi_source_location(const char* filename, int line) : std::string(std::string(filename) + ":" + std::to_string(line))
{
- 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;
-xbt_dict_t calls = nullptr; /* Allocated on first use */
+std::map<std::string, void*> calls;
+
#ifndef WIN32
static int smpi_shared_malloc_bogusfile = -1;
static int smpi_shared_malloc_bogusfile_huge_page = -1;
{
allocs.clear();
allocs_metadata.clear();
- xbt_dict_free(&calls);
+ calls.clear();
}
static size_t shm_size(int fd) {
size_t start_block_offset = ALIGN_UP(start_offset, smpi_shared_malloc_blocksize);
size_t stop_block_offset = ALIGN_DOWN(stop_offset, smpi_shared_malloc_blocksize);
for (unsigned block_id=0, i = start_block_offset / smpi_shared_malloc_blocksize; i < stop_block_offset / smpi_shared_malloc_blocksize; block_id++, i++) {
- XBT_DEBUG("\t\tglobal shared allocation, mmap block offset %d", block_id);
+ XBT_DEBUG("\t\tglobal shared allocation, mmap block offset %u", block_id);
void* pos = (void*)((unsigned long)mem + i * smpi_shared_malloc_blocksize);
void* res = mmap(pos, smpi_shared_malloc_blocksize, PROT_READ | PROT_WRITE, mmap_flag,
huge_fd, 0);
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;
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;
}
int smpi_shared_known_call(const char* func, const char* input)
{
- char* loc = bprintf("%s:%s", func, input);
- int known = 0;
-
- if (calls==nullptr) {
- calls = xbt_dict_new_homogeneous(nullptr);
- }
- try {
- xbt_dict_get(calls, loc); /* Succeed or throw */
- known = 1;
- xbt_free(loc);
- }
- catch (xbt_ex& ex) {
- xbt_free(loc);
- if (ex.category != not_found_error)
- throw;
- }
- catch(...) {
- xbt_free(loc);
- throw;
- }
- return known;
+ std::string loc = std::string(func) + ":" + input;
+ return calls.find(loc) != calls.end();
}
void* smpi_shared_get_call(const char* func, const char* input) {
- char* loc = bprintf("%s:%s", func, input);
+ std::string loc = std::string(func) + ":" + input;
- if (calls == nullptr)
- calls = xbt_dict_new_homogeneous(nullptr);
- void* data = xbt_dict_get(calls, loc);
- xbt_free(loc);
- return data;
+ return calls.at(loc);
}
void* smpi_shared_set_call(const char* func, const char* input, void* data) {
- char* loc = bprintf("%s:%s", func, input);
-
- if (calls == nullptr)
- calls = xbt_dict_new_homogeneous(nullptr);
- xbt_dict_set(calls, loc, data, nullptr);
- xbt_free(loc);
+ std::string loc = std::string(func) + ":" + input;
+ calls[loc] = data;
return data;
}
-
