shared_data_key_type* data;
};
-std::map<void*, shared_metadata_t> allocs_metadata;
+std::map<const void*, shared_metadata_t> allocs_metadata;
std::map<std::string, void*> calls;
#ifndef WIN32
void* mem = mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
if(mem == MAP_FAILED) {
- xbt_die(
- "Failed to map fd %d with size %zu: %s\n"
- "If you are running a lot of ranks, you may be exceeding the amount of mappings allowed per process.\n"
- "On Linux systems, change this value with sudo sysctl -w vm.max_map_count=newvalue (default value: 65536)\n"
- "Please see http://simgrid.gforge.inria.fr/simgrid/latest/doc/html/options.html#options_virt for more info.",
- fd, size, strerror(errno));
+ xbt_die("Failed to map fd %d with size %zu: %s\n"
+ "If you are running a lot of ranks, you may be exceeding the amount of mappings allowed per process.\n"
+ "On Linux systems, change this value with sudo sysctl -w vm.max_map_count=newvalue (default value: 65536)\n"
+ "Please see "
+ "https://simgrid.org/doc/latest/Configuring_SimGrid.html#configuring-the-user-code-virtualization for more "
+ "information.",
+ fd, size, strerror(errno));
}
snprintf(loc, PTR_STRLEN, "%p", mem);
meta.size = size;
}
// Align functions, from http://stackoverflow.com/questions/4840410/how-to-align-a-pointer-in-c
-#define PAGE_SIZE 0x1000
#define ALIGN_UP(n, align) (((n) + (align)-1) & -(align))
#define ALIGN_DOWN(n, align) ((n) & -(align))
-#define HUGE_PAGE_SIZE 1<<21
+constexpr unsigned PAGE_SIZE = 0x1000;
+constexpr unsigned HUGE_PAGE_SIZE = 1U << 21;
/* Similar to smpi_shared_malloc, but only sharing the blocks described by shared_block_offsets.
* This array contains the offsets (in bytes) of the block to share.
void* res = mmap(pos, smpi_shared_malloc_blocksize, PROT_READ | PROT_WRITE, mmap_flag,
huge_fd, 0);
xbt_assert(res == pos, "Could not map folded virtual memory (%s). Do you perhaps need to increase the "
- "size of the mapped file using --cfg=smpi/shared-malloc-blocksize=newvalue (default 1048576) ? "
+ "size of the mapped file using --cfg=smpi/shared-malloc-blocksize:newvalue (default 1048576) ? "
"You can also try using the sysctl vm.max_map_count. "
"If you are using huge pages, check that you have at least one huge page (/proc/sys/vm/nr_hugepages) "
"and that the directory you are passing is mounted correctly (mount /path/to/huge -t hugetlbfs -o rw,mode=0777).",
void* res = mmap(pos, low_page_stop_offset-low_page_start_offset, PROT_READ | PROT_WRITE, mmap_base_flag, // not a full huge page
smpi_shared_malloc_bogusfile, 0);
xbt_assert(res == pos, "Could not map folded virtual memory (%s). Do you perhaps need to increase the "
- "size of the mapped file using --cfg=smpi/shared-malloc-blocksize=newvalue (default 1048576) ?"
+ "size of the mapped file using --cfg=smpi/shared-malloc-blocksize:newvalue (default 1048576) ?"
"You can also try using the sysctl vm.max_map_count",
strerror(errno));
}
void* res = mmap(pos, high_page_stop_offset-stop_block_offset, PROT_READ | PROT_WRITE, mmap_base_flag, // not a full huge page
smpi_shared_malloc_bogusfile, 0);
xbt_assert(res == pos, "Could not map folded virtual memory (%s). Do you perhaps need to increase the "
- "size of the mapped file using --cfg=smpi/shared-malloc-blocksize=newvalue (default 1048576) ?"
+ "size of the mapped file using --cfg=smpi/shared-malloc-blocksize:newvalue (default 1048576) ?"
"You can also try using the sysctl vm.max_map_count",
strerror(errno));
}
return mem;
}
+
+void *smpi_shared_malloc_intercept(size_t size, const char *file, int line) {
+ if( simgrid::config::get_value<double>("smpi/auto-shared-malloc-thresh") == 0 || size < simgrid::config::get_value<double>("smpi/auto-shared-malloc-thresh"))
+ return ::operator new(size);
+ else
+ return smpi_shared_malloc(size, file, line);
+}
+
+void* smpi_shared_calloc_intercept(size_t num_elm, size_t elem_size, const char* file, int line){
+ if( simgrid::config::get_value<double>("smpi/auto-shared-malloc-thresh") == 0 || elem_size*num_elm < simgrid::config::get_value<double>("smpi/auto-shared-malloc-thresh")){
+ void* ptr = ::operator new(elem_size*num_elm);
+ memset(ptr, 0, elem_size*num_elm);
+ return ptr;
+ } else
+ return smpi_shared_malloc(elem_size*num_elm, file, line);
+
+}
+
void *smpi_shared_malloc(size_t size, const char *file, int line) {
if (size > 0 && smpi_cfg_shared_malloc == SharedMallocType::LOCAL) {
return smpi_shared_malloc_local(size, file, line);
return ::operator new(size);
}
-int smpi_is_shared(void* ptr, std::vector<std::pair<size_t, size_t>> &private_blocks, size_t *offset){
+int smpi_is_shared(const void* ptr, std::vector<std::pair<size_t, size_t>> &private_blocks, size_t *offset){
private_blocks.clear(); // being paranoid
if (allocs_metadata.empty())
return 0;
snprintf(loc, PTR_STRLEN, "%p", ptr);
auto meta = allocs_metadata.find(ptr);
if (meta == allocs_metadata.end()) {
- XBT_WARN("Cannot free: %p was not shared-allocated by SMPI - maybe its size was 0?", ptr);
+ ::operator delete(ptr);
return;
}
shared_data_t* data = &meta->second.data->second;
close(data->fd);
allocs.erase(allocs.find(meta->second.data->first));
allocs_metadata.erase(ptr);
- XBT_DEBUG("Shared free - with removal - of %p", ptr);
+ XBT_DEBUG("Shared free - Local - with removal - of %p", ptr);
} else {
- XBT_DEBUG("Shared free - no removal - of %p, count = %d", ptr, data->count);
+ XBT_DEBUG("Shared free - Local - no removal - of %p, count = %d", ptr, data->count);
}
} else if (smpi_cfg_shared_malloc == SharedMallocType::GLOBAL) {
auto meta = allocs_metadata.find(ptr);
if (meta != allocs_metadata.end()){
meta->second.data->second.count--;
- if(meta->second.data->second.count==0)
+ XBT_DEBUG("Shared free - Global - of %p", ptr);
+ munmap(ptr, meta->second.size);
+ if(meta->second.data->second.count==0){
delete meta->second.data;
+ allocs_metadata.erase(ptr);
+ }
+ }else{
+ ::operator delete(ptr);
+ return;
}
- munmap(ptr, meta->second.size);
} else {
XBT_DEBUG("Classic deallocation of %p", ptr);
::operator delete(ptr);
