-/* Copyright (c) 2007, 2009-2015. The SimGrid Team.
- * All rights reserved. */
+/* Copyright (c) 2007, 2009-2017. The SimGrid Team. All rights reserved. */
/* This program is free software; you can redistribute it and/or modify it
* under the terms of the license (GNU LGPL) which comes with this package. */
#ifndef WIN32
static void* shm_map(int fd, size_t size, shared_data_key_type* data) {
- void* mem;
char loc[PTR_STRLEN];
shared_metadata_t meta;
xbt_die("Could not truncate fd %d to %zu: %s", fd, size, strerror(errno));
}
- mem = mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
+ void* mem = mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
if(mem == MAP_FAILED) {
- xbt_die("Could not map fd %d with size %zu: %s.\n If you are running a lot of processes, you may be exceeding the amount of mappings allowed per process. \n On linux systems, this value can be set by using sudo sysctl -w vm.max_map_count=newvalue .\n Default value is 65536", 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 http://simgrid.gforge.inria.fr/simgrid/latest/doc/html/options.html#options_virt for more info.",
+ fd, size, strerror(errno));
}
snprintf(loc, PTR_STRLEN, "%p", mem);
meta.size = size;
int smpi_gettimeofday(struct timeval *tv, void* tz)
{
- double now;
smpi_bench_end();
- now = SIMIX_get_clock();
+ double now = SIMIX_get_clock();
if (tv) {
tv->tv_sec = static_cast<time_t>(now);
#ifdef WIN32
int smpi_clock_gettime(clockid_t clk_id, struct timespec *tp)
{
//there is only one time in SMPI, so clk_id is ignored.
- double now;
smpi_bench_end();
- now = SIMIX_get_clock();
+ double now = SIMIX_get_clock();
if (tp) {
tp->tv_sec = static_cast<time_t>(now);
tp->tv_nsec = static_cast<long int>((now - tp->tv_sec) * 1e9);
void smpi_sample_1(int global, const char *file, int line, int iters, double threshold)
{
char *loc = sample_location(global, file, line);
- local_data_t *data;
smpi_bench_end(); /* Take time from previous, unrelated computation into account */
smpi_process_set_sampling(1);
if (samples==nullptr)
samples = xbt_dict_new_homogeneous(free);
- data = static_cast<local_data_t *>(xbt_dict_get_or_null(samples, loc));
+ local_data_t *data = static_cast<local_data_t *>(xbt_dict_get_or_null(samples, loc));
if (data==nullptr) {
xbt_assert(threshold>0 || iters>0,
"You should provide either a positive amount of iterations to bench, or a positive maximal stderr (or both)");
int smpi_sample_2(int global, const char *file, int line)
{
char *loc = sample_location(global, file, line);
- local_data_t *data;
int res;
xbt_assert(samples, "Y U NO use SMPI_SAMPLE_* macros? Stop messing directly with smpi_sample_* functions!");
- data = static_cast<local_data_t *>(xbt_dict_get(samples, loc));
+ local_data_t *data = static_cast<local_data_t *>(xbt_dict_get(samples, loc));
XBT_DEBUG("sample2 %s",loc);
xbt_free(loc);
void smpi_sample_3(int global, const char *file, int line)
{
char *loc = sample_location(global, file, line);
- local_data_t *data;
xbt_assert(samples, "Y U NO use SMPI_SAMPLE_* macros? Stop messing directly with smpi_sample_* functions!");
- data = static_cast<local_data_t *>(xbt_dict_get(samples, loc));
+ local_data_t *data = static_cast<local_data_t *>(xbt_dict_get(samples, loc));
XBT_DEBUG("sample3 %s",loc);
xbt_free(loc);
- if (data->benching==0) {
+ if (data->benching==0)
THROW_IMPOSSIBLE;
- }
// ok, benchmarking this loop is over
xbt_os_threadtimer_stop(smpi_process_timer());
// update the stats
- double sample, n;
data->count++;
- sample = xbt_os_timer_elapsed(smpi_process_timer());
+ double sample = xbt_os_timer_elapsed(smpi_process_timer());
data->sum += sample;
data->sum_pow2 += sample * sample;
- n = static_cast<double>(data->count);
+ double 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)==0) {
void* smpi_shared_get_call(const char* func, const char* input) {
char* loc = bprintf("%s:%s", func, input);
- void* data;
- if(calls==nullptr) {
+ if (calls==nullptr)
calls = xbt_dict_new_homogeneous(nullptr);
- }
- data = xbt_dict_get(calls, loc);
+ void* data = xbt_dict_get(calls, 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==0) {
+ if (calls==nullptr)
calls = xbt_dict_new_homogeneous(nullptr);
- }
xbt_dict_set(calls, loc, data, nullptr);
xbt_free(loc);
return data;
* 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) {
+void smpi_really_switch_data_segment(int dest)
+{
if(smpi_size_data_exe == 0)//no need to switch
return;
return strncmp("/dev/shm/my-buffer-", file, std::strlen("/dev/shm/my-buffer-")) == 0;
}
-void smpi_initialize_global_memory_segments(){
+void smpi_initialize_global_memory_segments()
+{
#if !HAVE_PRIVATIZATION
smpi_privatize_global_variables=false;
if (smpi_size_data_exe == 0)//no need to switch
return;
#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) {
+ for (int i=0; i< smpi_process_count(); i++) {
+ if (munmap(smpi_privatisation_regions[i].address, smpi_size_data_exe) < 0)
XBT_WARN("Unmapping of fd %d failed: %s", smpi_privatisation_regions[i].file_descriptor, strerror(errno));
- }
close(smpi_privatisation_regions[i].file_descriptor);
}
xbt_free(smpi_privatisation_regions);
