/* 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. */
+#include <math.h> // sqrt
#include "private.h"
#include "xbt/dict.h"
#include "xbt/sysdep.h"
double relstderr;
int iters;
double threshold;
- int started;
+ int running;
} local_data_t;
void smpi_bench_destroy(void)
{
- if (allocs) {
- xbt_dict_free(&allocs);
- }
- if (samples) {
- xbt_dict_free(&samples);
- }
- if(calls) {
- xbt_dict_free(&calls);
- }
+ xbt_dict_free(&allocs);
+ xbt_dict_free(&samples);
+ xbt_dict_free(&calls);
}
static void smpi_execute_flops(double flops)
host = SIMIX_host_self();
XBT_DEBUG("Handle real computation time: %f flops", flops);
- action = SIMIX_req_host_execute("computation", host, flops, 1);
+ action = simcall_host_execute("computation", host, flops, 1);
#ifdef HAVE_TRACING
- SIMIX_req_set_category (action, TRACE_internal_smpi_get_category());
+ simcall_set_category (action, TRACE_internal_smpi_get_category());
#endif
- SIMIX_req_host_execution_wait(action);
+ simcall_host_execution_wait(action);
}
static void smpi_execute(double duration)
{
+ /* FIXME: a global variable would be less expensive to consult than a call to xbt_cfg_get_double() right on the critical path */
if (duration >= xbt_cfg_get_double(_surf_cfg_set, "smpi/cpu_threshold")) {
XBT_DEBUG("Sleep for %f to handle real computation time", duration);
smpi_execute_flops(duration *
xbt_cfg_get_double(_surf_cfg_set,
"smpi/running_power"));
+ } else {
+ XBT_DEBUG("Real computation took %f while threshold is set to %f; ignore it",
+ duration, xbt_cfg_get_double(_surf_cfg_set, "smpi/cpu_threshold"));
}
}
return 0;
}
+extern double sg_maxmin_precision;
+unsigned long long smpi_rastro_resolution (void)
+{
+ smpi_bench_end();
+ double resolution = (1/sg_maxmin_precision);
+ smpi_bench_begin();
+ return (unsigned long long)resolution;
+}
+
+unsigned long long smpi_rastro_timestamp (void)
+{
+ smpi_bench_end();
+ double now = SIMIX_get_clock();
+
+ 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;
+}
+
static char *sample_location(int global, const char *file, int line)
{
if (global) {
smpi_bench_end(); /* Take time from previous MPI call into account */
if (!samples) {
- samples = xbt_dict_new();
+ samples = xbt_dict_new_homogeneous(free);
}
data = xbt_dict_get_or_null(samples, loc);
if (!data) {
data->sum_pow2 = 0.0;
data->iters = iters;
data->threshold = threshold;
- data->started = 0;
- xbt_dict_set(samples, loc, data, &free);
+ data->running = 0;
+ xbt_dict_set(samples, loc, data, NULL);
return 0;
}
free(loc);
char *loc = sample_location(global, file, line);
local_data_t *data;
- xbt_assert(samples, "You did something very inconsistent, didn't you?");
+ xbt_assert(samples, "Y U NO use SMPI_SAMPLE_* macros? Stop messing directly with smpi_sample_* functions!");
data = xbt_dict_get_or_null(samples, loc);
if (!data) {
xbt_assert(data, "Please, do thing in order");
}
- if (!data->started) {
+ if (!data->running) {
if ((data->iters > 0 && data->count >= data->iters)
|| (data->count > 1 && data->threshold > 0.0 && data->relstderr <= data->threshold)) {
XBT_DEBUG("Perform some wait of %f", data->mean);
smpi_execute(data->mean);
} else {
- data->started = 1;
+ data->running = 1;
data->count++;
}
} else {
- data->started = 0;
+ data->running = 0;
}
free(loc);
smpi_bench_begin();
smpi_process_simulated_start();
- return data->started;
+ return data->running;
}
void smpi_sample_3(int global, const char *file, int line)
local_data_t *data;
double sample, n;
- xbt_assert(samples, "You did something very inconsistent, didn't you?");
+ xbt_assert(samples, "Y U NO use SMPI_SAMPLE_* macros? Stop messing directly with smpi_sample_* functions!");
data = xbt_dict_get_or_null(samples, loc);
smpi_bench_end();
- if(data && data->started && data->count < data->iters) {
+ if(data && data->running && data->count < data->iters) {
sample = smpi_process_simulated_elapsed();
data->sum += sample;
data->sum_pow2 += sample * sample;
}
}
if (!allocs) {
- allocs = xbt_dict_new();
+ allocs = xbt_dict_new_homogeneous(free);
}
data = xbt_dict_get_or_null(allocs, loc);
if(!data) {
if(shm_unlink(loc) < 0) {
XBT_WARN("Could not early unlink %s: %s", loc, strerror(errno));
}
- xbt_dict_set(allocs, loc, data, &free);
+ xbt_dict_set(allocs, loc, data, NULL);
XBT_DEBUG("Mapping %s at %p through %d", loc, mem, fd);
} else {
mem = shm_map(data->fd, size, data);
int known;
if(!calls) {
- calls = xbt_dict_new();
+ calls = xbt_dict_new_homogeneous(NULL);
}
TRY {
xbt_dict_get(calls, loc); /* Succeed or throw */
void* data;
if(!calls) {
- calls = xbt_dict_new();
+ calls = xbt_dict_new_homogeneous(NULL);
}
data = xbt_dict_get(calls, loc);
free(loc);
char* loc = bprintf("%s:%s", func, input);
if(!calls) {
- calls = xbt_dict_new();
+ calls = xbt_dict_new_homogeneous(NULL);
}
xbt_dict_set(calls, loc, data, NULL);
free(loc);