#include "src/internal_config.h"
#include "private.h"
+#include "private.hpp"
#include "xbt/dict.h"
#include "xbt/sysdep.h"
#include "xbt/ex.h"
int smpi_loaded_page = -1;
char* smpi_start_data_exe = NULL;
int smpi_size_data_exe = 0;
-int smpi_privatize_global_variables;
+bool smpi_privatize_global_variables;
double smpi_total_benched_time = 0;
smpi_privatisation_region_t smpi_privatisation_regions;
if(fstat(fd, &st) < 0) {
xbt_die("Could not stat fd %d: %s", fd, strerror(errno));
}
- return (size_t)st.st_size;
+ return static_cast<size_t>(st.st_size);
}
#ifndef WIN32
char loc[PTR_STRLEN];
shared_metadata_t meta;
- if(size > shm_size(fd)) {
- if(ftruncate(fd, (off_t)size) < 0) {
+ if(size > shm_size(fd) && (ftruncate(fd, static_cast<off_t>(size)) < 0)) {
xbt_die("Could not truncate fd %d to %zu: %s", fd, size, strerror(errno));
- }
}
mem = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
if (MC_is_active() || MC_record_replay_is_active())
return;
+ double speedup = 1;
xbt_os_timer_t timer = smpi_process_timer();
xbt_os_threadtimer_stop(timer);
-// smpi_switch_data_segment(smpi_process_count());
if (smpi_process_get_sampling()) {
XBT_CRITICAL("Cannot do recursive benchmarks.");
XBT_CRITICAL("Are you trying to make a call to MPI within a SMPI_SAMPLE_ block?");
xbt_backtrace_display_current();
xbt_die("Aborting.");
}
+
+ if (xbt_cfg_get_string("smpi/comp-adjustment-file")[0] != '\0') { // Maybe we need to artificially speed up or slow
+ // down our computation based on our statistical analysis.
+
+ smpi_trace_call_location_t* loc = smpi_process_get_call_location();
+ std::string key = loc->get_composed_key();
+ std::unordered_map<std::string, double>::const_iterator it = location2speedup.find(key);
+ if (it != location2speedup.end()) {
+ speedup = it->second;
+ }
+ }
+
// Simulate the benchmarked computation unless disabled via command-line argument
- if (sg_cfg_get_boolean("smpi/simulate_computation")) {
- smpi_execute(xbt_os_timer_elapsed(timer));
+ if (xbt_cfg_get_boolean("smpi/simulate-computation")) {
+ smpi_execute(xbt_os_timer_elapsed(timer)/speedup);
}
smpi_total_benched_time += xbt_os_timer_elapsed(timer);
unsigned int smpi_sleep(unsigned int secs)
{
- return private_sleep((double)secs);
+ return private_sleep(static_cast<double>(secs));
}
int smpi_usleep(useconds_t usecs)
{
- return (int)private_sleep((double)usecs / 1000000.0);
+ return static_cast<int>(private_sleep(static_cast<double>(usecs) / 1000000.0));
}
int smpi_gettimeofday(struct timeval *tv, void* tz)
smpi_bench_end();
now = SIMIX_get_clock();
if (tv) {
- tv->tv_sec = (time_t)now;
+ tv->tv_sec = static_cast<time_t>(now);
#ifdef WIN32
- tv->tv_usec = (useconds_t)((now - tv->tv_sec) * 1e6);
+ tv->tv_usec = static_cast<useconds_t>((now - tv->tv_sec) * 1e6);
#else
- tv->tv_usec = (suseconds_t)((now - tv->tv_sec) * 1e6);
+ tv->tv_usec = static_cast<suseconds_t>((now - tv->tv_sec) * 1e6);
#endif
}
smpi_bench_begin();
smpi_bench_end();
double resolution = (1/sg_surf_precision);
smpi_bench_begin();
- return (unsigned long long)resolution;
+ return static_cast<unsigned long long>(resolution);
}
unsigned long long smpi_rastro_timestamp (void)
unsigned long long sec = (unsigned long long)now;
unsigned long long pre = (now - sec) * smpi_rastro_resolution();
smpi_bench_begin();
- return (unsigned long long)sec * smpi_rastro_resolution() + pre;
+ return static_cast<unsigned long long>(sec) * smpi_rastro_resolution() + pre;
}
/* ****************************** Functions related to the SMPI_SAMPLE_ macros ************************************/
smpi_bench_end(); /* Take time from previous, unrelated computation into account */
smpi_process_set_sampling(1);
- if (!samples)
+ if (samples==NULL)
samples = xbt_dict_new_homogeneous(free);
data = static_cast<local_data_t *>(xbt_dict_get_or_null(samples, loc));
- if (!data) {
+ if (data==NULL) {
xbt_assert(threshold>0 || iters>0,
"You should provide either a positive amount of iterations to bench, or a positive maximal stderr (or both)");
- data = (local_data_t *) xbt_new(local_data_t, 1);
+ data = static_cast<local_data_t *>( xbt_new(local_data_t, 1));
data->count = 0;
data->sum = 0.0;
data->sum_pow2 = 0.0;
// if we already have some data, check whether sample_2 should get one more bench or whether it should emulate
// the computation instead
- data->benching = !sample_enough_benchs(data);
+ data->benching = (sample_enough_benchs(data) == 0);
XBT_DEBUG("XXXX Re-entering the benched nest %s. %s",loc,
(data->benching?"more benching needed":"we have enough data, skip computes"));
}
sample = xbt_os_timer_elapsed(smpi_process_timer());
data->sum += sample;
data->sum_pow2 += sample * sample;
- n = (double)data->count;
+ n = static_cast<double>(data->count);
data->mean = data->sum / n;
data->relstderr = sqrt((data->sum_pow2 / n - data->mean * data->mean) / n) / data->mean;
- if (!sample_enough_benchs(data)) {
+ if (sample_enough_benchs(data)==0) {
data->mean = sample; // Still in benching process; We want sample_2 to simulate the exact time of this loop
// occurrence before leaving, not the mean over the history
}
void *smpi_shared_malloc(size_t size, const char *file, int line)
{
void* mem;
- if (sg_cfg_get_boolean("smpi/use_shared_malloc")){
+ if (xbt_cfg_get_boolean("smpi/use-shared-malloc")){
int fd;
smpi_source_location loc(file, line);
auto res = allocs.insert(std::make_pair(loc, shared_data_t()));
snprintf(shmname, 31, "/shmalloc%p", &*data);
fd = shm_open(shmname, O_RDWR | O_CREAT | O_EXCL, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
if (fd < 0) {
- switch(errno) {
- case EEXIST:
- xbt_die("Please cleanup /dev/shm/%s", shmname);
- default:
- xbt_die("An unhandled error occured while opening %s. shm_open: %s", shmname, strerror(errno));
- }
+ if(errno==EEXIST)
+ xbt_die("Please cleanup /dev/shm/%s", shmname);
+ else
+ xbt_die("An unhandled error occurred while opening %s. shm_open: %s", shmname, strerror(errno));
}
data->second.fd = fd;
data->second.count = 1;
{
char loc[PTR_STRLEN];
- if (sg_cfg_get_boolean("smpi/use_shared_malloc")){
+ if (xbt_cfg_get_boolean("smpi/use-shared-malloc")){
snprintf(loc, PTR_STRLEN, "%p", ptr);
auto meta = allocs_metadata.find(ptr);
if (meta == allocs_metadata.end()) {
xbt_ex_t ex;
int known = 0;
- if (!calls) {
+ if (calls==NULL) {
calls = xbt_dict_new_homogeneous(NULL);
}
TRY {
char* loc = bprintf("%s:%s", func, input);
void* data;
- if(!calls) {
+ if(calls==NULL) {
calls = xbt_dict_new_homogeneous(NULL);
}
data = xbt_dict_get(calls, loc);
- free(loc);
+ xbt_free(loc);
return data;
}
void* smpi_shared_set_call(const char* func, const char* input, void* data) {
char* loc = bprintf("%s:%s", func, input);
- if(!calls) {
+ if(calls==0) {
calls = xbt_dict_new_homogeneous(NULL);
}
xbt_dict_set(calls, loc, data, NULL);
- free(loc);
+ xbt_free(loc);
return data;
}
if(smpi_size_data_exe == 0)//no need to switch
return;
-#ifdef HAVE_PRIVATIZATION
+#if HAVE_PRIVATIZATION
if(smpi_loaded_page==-1){//initial switch, do the copy from the real page here
for (int i=0; i< smpi_process_count(); i++){
memcpy(smpi_privatisation_regions[i].address, TOPAGE(smpi_start_data_exe), smpi_size_data_exe);
void smpi_initialize_global_memory_segments(){
-#ifndef HAVE_PRIVATIZATION
- smpi_privatize_global_variables=0;
+#if !HAVE_PRIVATIZATION
+ smpi_privatize_global_variables=false;
xbt_die("You are trying to use privatization on a system that does not support it. Don't.");
return;
#else
XBT_DEBUG ("bss+data segment found : size %d starting at %p", smpi_size_data_exe, smpi_start_data_exe );
if (smpi_size_data_exe == 0){//no need to switch
- smpi_privatize_global_variables=0;
+ smpi_privatize_global_variables=false;
return;
}
smpi_privatisation_regions =
- (smpi_privatisation_region_t) malloc(smpi_process_count() * sizeof(struct s_smpi_privatisation_region));
+ static_cast<smpi_privatisation_region_t>( xbt_malloc(smpi_process_count() * sizeof(struct s_smpi_privatisation_region)));
for (int i=0; i< smpi_process_count(); i++){
//create SIMIX_process_count() mappings of this size with the same data inside
void smpi_destroy_global_memory_segments(){
if (smpi_size_data_exe == 0)//no need to switch
return;
-#ifdef HAVE_PRIVATIZATION
+#if HAVE_PRIVATIZATION
int i;
for (i=0; i< smpi_process_count(); i++){
if(munmap(smpi_privatisation_regions[i].address, smpi_size_data_exe) < 0) {
xbt_free(smpi_privatisation_regions);
#endif
}
+
+extern "C" { /** These functions will be called from the user code **/
+ smpi_trace_call_location_t* smpi_trace_get_call_location() {
+ return smpi_process_get_call_location();
+ }
+
+ void smpi_trace_set_call_location(const char* file, const int line) {
+ smpi_trace_call_location_t* loc = smpi_process_get_call_location();
+
+ loc->previous_filename = loc->filename;
+ loc->previous_linenumber = loc->linenumber;
+ loc->filename = file;
+ loc->linenumber = line;
+ }
+
+ /**
+ * Required for Fortran bindings
+ */
+ void smpi_trace_set_call_location_(const char* file, int* line) {
+ smpi_trace_set_call_location(file, *line);
+ }
+
+ /**
+ * Required for Fortran if -fsecond-underscore is activated
+ */
+ void smpi_trace_set_call_location__(const char* file, int* line) {
+ smpi_trace_set_call_location(file, *line);
+ }
+}
