X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/fc7f41210475aadebbc93854d2005281435a2168..eca09d65271990fdae84e1d7da71916740a9c50b:/src/smpi/smpi_bench.c diff --git a/src/smpi/smpi_bench.c b/src/smpi/smpi_bench.c index 0a74d87a4c..26f7c542ee 100644 --- a/src/smpi/smpi_bench.c +++ b/src/smpi/smpi_bench.c @@ -12,6 +12,7 @@ #include "xbt/hash.h" #include "surf/surf.h" #include "simgrid/sg_config.h" +#include "simgrid/modelchecker.h" #ifndef WIN32 #include @@ -73,12 +74,14 @@ xbt_dict_t calls = NULL; /* Allocated on first use */ double smpi_cpu_threshold; double smpi_running_power; -static int* fds; -void** mappings; int smpi_loaded_page = -1; char* start_data_exe = NULL; int size_data_exe = 0; int smpi_privatize_global_variables; +double smpi_total_benched_time = 0; + + +smpi_privatisation_region_t smpi_privatisation_regions; typedef struct { int fd; @@ -150,7 +153,7 @@ void smpi_execute_(double *duration) } void smpi_execute_flops(double flops) { - smx_action_t action; + smx_synchro_t action; smx_host_t host; host = SIMIX_host_self(); XBT_DEBUG("Handle real computation time: %f flops", flops); @@ -159,6 +162,7 @@ void smpi_execute_flops(double flops) { simcall_set_category (action, TRACE_internal_smpi_get_category()); #endif simcall_host_execution_wait(action); + smpi_switch_data_segment(smpi_process_index()); } void smpi_execute(double duration) @@ -190,11 +194,19 @@ void smpi_switch_data_segment(int dest); void smpi_bench_begin(void) { smpi_switch_data_segment(smpi_process_index()); + + if (MC_is_active() || MC_record_replay_is_active()) + return; + xbt_os_threadtimer_start(smpi_process_timer()); } void smpi_bench_end(void) { + + if (MC_is_active() || MC_record_replay_is_active()) + return; + xbt_os_timer_t timer = smpi_process_timer(); xbt_os_threadtimer_stop(timer); // smpi_switch_data_segment(smpi_process_count()); @@ -208,6 +220,8 @@ void smpi_bench_end(void) if (sg_cfg_get_boolean("smpi/simulate_computation")) { smpi_execute(xbt_os_timer_elapsed(timer)); } + + smpi_total_benched_time += xbt_os_timer_elapsed(timer); } /* Private sleep function used by smpi_sleep() and smpi_usleep() */ @@ -593,32 +607,39 @@ void* smpi_shared_set_call(const char* func, const char* input, void* data) { #define TOPAGE(addr) (void *)(((unsigned long)(addr) / xbt_pagesize) * xbt_pagesize) -/* - * - read the executable data+bss section addresses and sizes - * - for each process create a copy of these sections with mmap - * - store them in a dynar - * +/** Map a given SMPI privatization segment (make a SMPI process active) */ +void smpi_switch_data_segment(int dest){ + if (smpi_loaded_page==dest)//no need to switch either + return; + // So the job: + smpi_really_switch_data_segment(dest); +} -void smpi_switch_data_segment(int dest){ +/** Map a given SMPI privatization segment (make a SMPI process active) + * even if SMPI thinks it is already active + * + * When doing a state restoration, the state of the restored variables + * might not be consistent with the state of the virtual memory. + * In this case, we to change the data segment. + */ +void smpi_really_switch_data_segment(int dest) { if(size_data_exe == 0)//no need to switch return; - if (smpi_loaded_page==dest)//no need to switch either - return; - #ifdef HAVE_MMAP int i; if(smpi_loaded_page==-1){//initial switch, do the copy from the real page here for (i=0; i< SIMIX_process_count(); i++){ - memcpy(mappings[i],TOPAGE(start_data_exe),size_data_exe); + memcpy(smpi_privatisation_regions[i].address,TOPAGE(start_data_exe),size_data_exe); } } - int current= fds[dest]; - XBT_VERB("Switching data frame to the one of process %d", dest); + + int current = smpi_privatisation_regions[dest].file_descriptor; + XBT_DEBUG("Switching data frame to the one of process %d", dest); void* tmp = mmap (TOPAGE(start_data_exe), size_data_exe, PROT_READ | PROT_WRITE, MAP_FIXED | MAP_SHARED, current, 0); if (tmp != TOPAGE(start_data_exe)) xbt_die("Couldn't map the new region"); @@ -626,6 +647,11 @@ void smpi_switch_data_segment(int dest){ #endif } +int smpi_is_privatisation_file(char* file) +{ + return strncmp("/dev/shm/my-buffer-", file, 19) == 0; +} + void smpi_get_executable_global_size(){ int size_bss_binary=0; int size_data_binary=0; @@ -717,18 +743,36 @@ void smpi_initialize_global_memory_segments(){ return; } - fds= (int*)xbt_malloc((smpi_process_count())*sizeof(int)); - mappings= (void**)xbt_malloc((smpi_process_count())*sizeof(void*)); - + smpi_privatisation_regions = (smpi_privatisation_region_t) malloc( + smpi_process_count() * sizeof(struct s_smpi_privatisation_region)); for (i=0; i< SIMIX_process_count(); i++){ //create SIMIX_process_count() mappings of this size with the same data inside void *address = NULL; char path[] = "/dev/shm/my-buffer-XXXXXX"; int status; + int file_descriptor= mkstemp (path); - if (file_descriptor < 0) - xbt_die("Impossible to create temporary file for memory mapping"); + if (file_descriptor < 0) { + if (errno==EMFILE) { + xbt_die("Impossible to create temporary file for memory mapping: %s\n\ +The open() system call failed with the EMFILE error code (too many files). \n\n\ +This means that you reached the system limits concerning the amount of files per process. \ +This is not a surprise if you are trying to virtualize many processes on top of SMPI. \ +Don't panic -- you should simply increase your system limits and try again. \n\n\ +First, check what your limits are:\n\ + cat /proc/sys/fs/file-max # Gives you the system-wide limit\n\ + ulimit -Hn # Gives you the per process hard limit\n\ + ulimit -Sn # Gives you the per process soft limit\n\ + cat /proc/self/limits # Displays any per-process limitation (including the one given above)\n\n\ +If one of these values is less than the amount of MPI processes that you try to run, then you got the explanation of this error. \ +Ask the Internet about tutorials on how to increase the files limit such as: https://rtcamp.com/tutorials/linux/increase-open-files-limit/", + strerror(errno)); + } + xbt_die("Impossible to create temporary file for memory mapping: %s", + strerror(errno)); + } + status = unlink (path); if (status) xbt_die("Impossible to unlink temporary file for memory mapping"); @@ -739,7 +783,6 @@ void smpi_initialize_global_memory_segments(){ /* Ask for a free region */ address = mmap (NULL, size_data_exe, PROT_READ | PROT_WRITE, MAP_SHARED, file_descriptor, 0); - if (address == MAP_FAILED) xbt_die("Couldn't find a free region for memory mapping"); @@ -747,8 +790,8 @@ void smpi_initialize_global_memory_segments(){ memcpy(address,TOPAGE(start_data_exe),size_data_exe); //store the address of the mapping for further switches - fds[i]=file_descriptor; - mappings[i]= address; + smpi_privatisation_regions[i].file_descriptor = file_descriptor; + smpi_privatisation_regions[i].address = address; } #endif @@ -761,14 +804,13 @@ void smpi_destroy_global_memory_segments(){ #ifdef HAVE_MMAP int i; for (i=0; i< smpi_process_count(); i++){ - if(munmap(mappings[i],size_data_exe) < 0) { - XBT_WARN("Unmapping of fd %d failed: %s", fds[i], strerror(errno)); + if(munmap(smpi_privatisation_regions[i].address,size_data_exe) < 0) { + XBT_WARN("Unmapping of fd %d failed: %s", + smpi_privatisation_regions[i].file_descriptor, strerror(errno)); } - close(fds[i]); + close(smpi_privatisation_regions[i].file_descriptor); } - xbt_free(mappings); - xbt_free(fds); - + xbt_free(smpi_privatisation_regions); #endif }