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 = xbt_dict_get(samples, loc);
XBT_DEBUG("sample3 %s",loc);
if (data->benching==0) {
THROW_IMPOSSIBLE;
}
// ok, benchmarking this loop is over
xbt_os_timer_stop(smpi_process_timer());
// update the stats
double sample, n;
data->count++;
sample = xbt_os_timer_elapsed(smpi_process_timer());
data->sum += sample;
data->sum_pow2 += sample * sample;
n = (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)) {
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
}
XBT_DEBUG("Average mean after %d steps is %f, relative standard error is %f (sample was %f)", data->count,
data->mean, data->relstderr, sample);
// That's enough for now, prevent sample_2 to run the same code over and over
data->benching = 0;
}
int smpi_sample_2(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 = xbt_dict_get(samples, loc);
XBT_DEBUG("sample2 %s",loc);
free(loc);
if (data->benching==1) {
// we need to run a new bench
XBT_DEBUG("benchmarking: count:%d iter:%d stderr:%f thres:%f; mean:%f",
data->count, data->iters, data->relstderr, data->threshold, data->mean);
smpi_bench_begin();
return 1;
} else {
// Enough data, no more bench (either we got enough data from previous visits to this benched nest, or we just ran one bench and need to bail out now that our job is done).
// Just sleep instead
XBT_DEBUG("No benchmark (either no need, or just ran one): count >= iter (%d >= %d) or stderr<thres (%f<=%f). apply the %fs delay instead",
data->count, data->iters, data->relstderr, data->threshold, data->mean);
smpi_execute(data->mean);
smpi_bench_begin(); // prepare to capture future, unrelated computations
return 0;
}
}
int smpi_sample_2(int global, const char *file, int line)
{
char *loc = sample_location(global, file, line);
local_data_t *data;
xbt_assert(samples, "You did something very inconsistent, didn't you?");
data = xbt_dict_get_or_null(samples, loc);
if (!data) {
xbt_assert(data, "Please, do thing in order");
}
if (!data->started) {
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->count++;
}
} else {
data->started = 0;
}
free(loc);
smpi_bench_begin();
smpi_process_simulated_start();
return data->started;
}
void smpi_sample_3(int global, const char *file, int line)
{
char *loc = sample_location(global, file, line);
local_data_t *data;
double sample, n;
xbt_assert(samples, "You did something very inconsistent, didn't you?");
data = xbt_dict_get_or_null(samples, loc);
smpi_bench_end();
if(data && data->started && data->count < data->iters) {
sample = smpi_process_simulated_elapsed();
data->sum += sample;
data->sum_pow2 += sample * sample;
n = (double)data->count;
data->mean = data->sum / n;
data->relstderr = sqrt((data->sum_pow2 / n - data->mean * data->mean) / n) / data->mean;
XBT_DEBUG("Average mean after %d steps is %f, relative standard error is %f (sample was %f)", data->count,
data->mean, data->relstderr, sample);
}
free(loc);
}
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 */
if (!samples)
samples = xbt_dict_new_homogeneous(free);
data = xbt_dict_get_or_null(samples, loc);
if (!data) {
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->count = 0;
data->sum = 0.0;
data->sum_pow2 = 0.0;
data->iters = iters;
data->threshold = threshold;
data->benching = 1; // If we have no data, we need at least one
data->mean = 0;
xbt_dict_set(samples, loc, data, NULL);
XBT_DEBUG("XXXXX First time ever on benched nest %s.",loc);
} else {
if (data->iters != iters || data->threshold != threshold) {
XBT_ERROR("Asked to bench block %s with different settings %d, %f is not %d, %f. How did you manage to give two numbers at the same line??",
loc, data->iters, data->threshold, iters,threshold);
THROW_IMPOSSIBLE;
}
// 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);
XBT_DEBUG("XXXX Re-entering the benched nest %s. %s",loc, (data->benching?"more benching needed":"we have enough data, skip computes"));
}
free(loc);
}
int 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 MPI call into account */
if (!samples) {
samples = xbt_dict_new();
}
data = xbt_dict_get_or_null(samples, loc);
if (!data) {
data = (local_data_t *) xbt_new(local_data_t, 1);
data->count = 0;
data->sum = 0.0;
data->sum_pow2 = 0.0;
data->iters = iters;
data->threshold = threshold;
data->started = 0;
xbt_dict_set(samples, loc, data, &free);
return 0;
}
free(loc);
return 1;
}