X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/2155dbd23cfe5c344d2ac177e7bfee31e9259ff9..e0ba02850ce33d8eda9ba10a68db10af76f0ef29:/src/smpi/smpi_global.cpp diff --git a/src/smpi/smpi_global.cpp b/src/smpi/smpi_global.cpp index 72dff8954d..5910e15e82 100644 --- a/src/smpi/smpi_global.cpp +++ b/src/smpi/smpi_global.cpp @@ -14,6 +14,7 @@ #include "private.h" #include "private.hpp" #include "simgrid/s4u/Mailbox.hpp" +#include "smpi/smpi_shared_malloc.hpp" #include "simgrid/sg_config.h" #include "src/kernel/activity/SynchroComm.hpp" #include "src/mc/mc_record.h" @@ -129,49 +130,86 @@ void smpi_comm_set_copy_data_callback(void (*callback) (smx_activity_t, void*, s smpi_comm_copy_data_callback = callback; } -void smpi_comm_copy_buffer_callback(smx_activity_t synchro, void *buff, size_t buff_size) +static void print(std::vector> vec) { + std::fprintf(stderr, "{"); + for (auto 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>& private_blocks) { + for(auto block : private_blocks) { + memcpy((uint8_t*)dest+block.first, (uint8_t*)src+block.first, block.second-block.first); + } +} - simgrid::kernel::activity::Comm *comm = dynamic_cast(synchro); +static void check_blocks(std::vector> &private_blocks, size_t buff_size) { + for(auto block : private_blocks) { + xbt_assert(block.first <= block.second && block.second <= buff_size, "Oops, bug in shared malloc."); + } +} +void smpi_comm_copy_buffer_callback(smx_activity_t synchro, void *buff, size_t buff_size) +{ + simgrid::kernel::activity::Comm *comm = dynamic_cast(synchro); + int src_shared = 0; + int dst_shared = 0; + size_t src_offset = 0; + size_t dst_offset = 0; + std::vector> src_private_blocks; + std::vector> dst_private_blocks; XBT_DEBUG("Copy the data over"); - if(smpi_is_shared(buff)){ + if((src_shared=smpi_is_shared(buff, src_private_blocks, &src_offset))) { XBT_DEBUG("Sender %p is shared. Let's ignore it.", buff); - }else if(smpi_is_shared((char*)comm->dst_buff)){ + src_private_blocks = shift_and_frame_private_blocks(src_private_blocks, src_offset, buff_size); + } + else { + src_private_blocks.clear(); + src_private_blocks.push_back(std::make_pair(0, buff_size)); + } + if((dst_shared=smpi_is_shared((char*)comm->dst_buff, dst_private_blocks, &dst_offset))) { XBT_DEBUG("Receiver %p is shared. Let's ignore it.", (char*)comm->dst_buff); - }else{ - void* tmpbuff=buff; - if((smpi_privatize_global_variables == SMPI_PRIVATIZE_MMAP) && (static_cast(buff) >= smpi_start_data_exe) - && (static_cast(buff) < smpi_start_data_exe + smpi_size_data_exe ) - ){ - XBT_DEBUG("Privatization : We are copying from a zone inside global memory... Saving data to temp buffer !"); - - smpi_switch_data_segment( - (static_cast((static_cast(comm->src_proc->data)->data))->index())); - tmpbuff = static_cast(xbt_malloc(buff_size)); - memcpy(tmpbuff, buff, buff_size); - } - - if((smpi_privatize_global_variables == SMPI_PRIVATIZE_MMAP) && ((char*)comm->dst_buff >= smpi_start_data_exe) - && ((char*)comm->dst_buff < smpi_start_data_exe + smpi_size_data_exe )){ - XBT_DEBUG("Privatization : We are copying to a zone inside global memory - Switch data segment"); - smpi_switch_data_segment( - (static_cast((static_cast(comm->dst_proc->data)->data))->index())); - } - - XBT_DEBUG("Copying %zu bytes from %p to %p", buff_size, tmpbuff,comm->dst_buff); - memcpy(comm->dst_buff, tmpbuff, buff_size); + dst_private_blocks = shift_and_frame_private_blocks(dst_private_blocks, dst_offset, buff_size); + } + else { + dst_private_blocks.clear(); + dst_private_blocks.push_back(std::make_pair(0, buff_size)); + } + check_blocks(src_private_blocks, buff_size); + check_blocks(dst_private_blocks, buff_size); + auto private_blocks = merge_private_blocks(src_private_blocks, dst_private_blocks); + check_blocks(private_blocks, buff_size); + void* tmpbuff=buff; + if((smpi_privatize_global_variables == SMPI_PRIVATIZE_MMAP) && (static_cast(buff) >= smpi_start_data_exe) + && (static_cast(buff) < smpi_start_data_exe + smpi_size_data_exe ) + ){ + XBT_DEBUG("Privatization : We are copying from a zone inside global memory... Saving data to temp buffer !"); + + smpi_switch_data_segment( + (static_cast((static_cast(comm->src_proc->data)->data))->index())); + tmpbuff = static_cast(xbt_malloc(buff_size)); + memcpy_private(tmpbuff, buff, private_blocks); + } - if (comm->detached) { - // if this is a detached send, the source buffer was duplicated by SMPI - // sender to make the original buffer available to the application ASAP - xbt_free(buff); - //It seems that the request is used after the call there this should be free somewhere else but where??? - //xbt_free(comm->comm.src_data);// inside SMPI the request is kept inside the user data and should be free - comm->src_buff = nullptr; - } - if(tmpbuff!=buff)xbt_free(tmpbuff); + if((smpi_privatize_global_variables == SMPI_PRIVATIZE_MMAP) && ((char*)comm->dst_buff >= smpi_start_data_exe) + && ((char*)comm->dst_buff < smpi_start_data_exe + smpi_size_data_exe )){ + XBT_DEBUG("Privatization : We are copying to a zone inside global memory - Switch data segment"); + smpi_switch_data_segment( + (static_cast((static_cast(comm->dst_proc->data)->data))->index())); + } + XBT_DEBUG("Copying %zu bytes from %p to %p", buff_size, tmpbuff,comm->dst_buff); + memcpy_private(comm->dst_buff, tmpbuff, private_blocks); + + if (comm->detached) { + // if this is a detached send, the source buffer was duplicated by SMPI + // sender to make the original buffer available to the application ASAP + xbt_free(buff); + //It seems that the request is used after the call there this should be free somewhere else but where??? + //xbt_free(comm->comm.src_data);// inside SMPI the request is kept inside the user data and should be free + comm->src_buff = nullptr; } + if(tmpbuff!=buff)xbt_free(tmpbuff); } @@ -402,13 +440,13 @@ static void smpi_init_logs(){ static void smpi_init_options(){ //return if already called - if(smpi_cpu_threshold!=-1) + if (smpi_cpu_threshold > -1) return; simgrid::smpi::Colls::set_collectives(); simgrid::smpi::Colls::smpi_coll_cleanup_callback=nullptr; smpi_cpu_threshold = xbt_cfg_get_double("smpi/cpu-threshold"); smpi_host_speed = xbt_cfg_get_double("smpi/host-speed"); - const char* smpi_privatize_option = xbt_cfg_get_string("smpi/privatize-global-variables"); + const char* smpi_privatize_option = xbt_cfg_get_string("smpi/privatization"); if (std::strcmp(smpi_privatize_option, "no") == 0) smpi_privatize_global_variables = SMPI_PRIVATIZE_NONE; else if (std::strcmp(smpi_privatize_option, "yes") == 0) @@ -425,8 +463,7 @@ static void smpi_init_options(){ smpi_privatize_global_variables = SMPI_PRIVATIZE_NONE; else - xbt_die("Invalid value for smpi/privatize-global-variables: %s", - smpi_privatize_option); + xbt_die("Invalid value for smpi/privatization: %s", smpi_privatize_option); if (smpi_cpu_threshold < 0) smpi_cpu_threshold = DBL_MAX; @@ -446,7 +483,7 @@ static void smpi_init_options(){ typedef std::function smpi_entry_point_type; typedef int (* smpi_c_entry_point_type)(int argc, char **argv); -typedef void (* smpi_fortran_entry_point_type)(void); +typedef void (*smpi_fortran_entry_point_type)(); static int smpi_run_entry_point(smpi_entry_point_type entry_point, std::vector args) { @@ -467,20 +504,17 @@ static int smpi_run_entry_point(smpi_entry_point_type entry_point, std::vector= 0, "Cannot write into %s", target_executable.c_str()); #if HAVE_SENDFILE - sendfile(fdout, fdin, NULL, fdin_size); + off_t offset = 0; + sendfile(fdout, fdin, &offset, fdin_size); #else XBT_WARN("Copy %d bytes into %s", static_cast(fdin_size), target_executable.c_str()); const int bufsize = 1024 * 1024 * 4;