From 8886e06558103ffcb66db5039f010eaad20aa854 Mon Sep 17 00:00:00 2001 From: pini Date: Mon, 27 Sep 2010 10:18:49 +0000 Subject: [PATCH] Added local and global sampling. git-svn-id: svn+ssh://scm.gforge.inria.fr/svn/simgrid/simgrid/trunk@8216 48e7efb5-ca39-0410-a469-dd3cf9ba447f --- include/smpi/mpi.h | 3 - include/smpi/smpi.h | 21 ++++--- src/smpi/private.h | 2 + src/smpi/smpi_bench.c | 134 +++++++++++++++++++++++++++-------------- src/smpi/smpi_global.c | 13 ++++ 5 files changed, 115 insertions(+), 58 deletions(-) diff --git a/include/smpi/mpi.h b/include/smpi/mpi.h index b295aac041..fdaf9df4b1 100644 --- a/include/smpi/mpi.h +++ b/include/smpi/mpi.h @@ -14,10 +14,7 @@ #include #include -/* #define sleep(x) smpi_sleep(x) #define gettimeofday(x, y) smpi_gettimeofday(x, y) -#define main(x, y) smpi_simulated_main(x, y) -*/ #endif diff --git a/include/smpi/smpi.h b/include/smpi/smpi.h index fc4e0873e7..c6540cde10 100644 --- a/include/smpi/smpi.h +++ b/include/smpi/smpi.h @@ -237,19 +237,22 @@ XBT_PUBLIC(int) MPI_Comm_split(MPI_Comm comm, int color, int key, XBT_IMPORT_NO_EXPORT(int) smpi_simulated_main(int argc, char** argv); XBT_PUBLIC(MPI_Comm) smpi_process_comm_self(void); /* -XBT_PUBLIC(unsigned int) smpi_sleep(unsigned int); XBT_PUBLIC(void) smpi_exit(int); -XBT_PUBLIC(int) smpi_gettimeofday(struct timeval* tv, struct timezone* tz); */ -/* -TODO -XBT_PUBLIC(void) smpi_do_once_1(const char* file, int line); -XBT_PUBLIC(int) smpi_do_once_2(void); -XBT_PUBLIC(void) smpi_do_once_3(void); +XBT_PUBLIC(unsigned int) smpi_sleep(unsigned int secs); +XBT_PUBLIC(int) smpi_gettimeofday(struct timeval* tv, struct timezone* tz); +XBT_PUBLIC(void) smpi_sample_1(int global, const char* file, int line, int max); +XBT_PUBLIC(int) smpi_sample_2(int global, const char* file, int line); +XBT_PUBLIC(void) smpi_sample_3(int global, const char* file, int line); -#define SMPI_DO_ONCE for (smpi_do_once_1(__FILE__, __LINE__); smpi_do_once_2(); smpi_do_once_3()) -*/ +#define SMPI_SAMPLE_LOCAL(num) for(smpi_sample_1(0, __FILE__, __LINE__, num); \ + smpi_sample_2(0, __FILE__, __LINE__); \ + smpi_sample_3(0, __FILE__, __LINE__)) + +#define SMPI_SAMPLE_GLOBAL(num) for(smpi_sample_1(1, __FILE__, __LINE__, num); \ + smpi_sample_2(1, __FILE__, __LINE__); \ + smpi_sample_3(1, __FILE__, __LINE__)) XBT_PUBLIC(void*) smpi_shared_malloc(size_t size, const char* file, int line); #define SMPI_SHARED_MALLOC(size) smpi_shared_malloc(size, __FILE__, __LINE__) diff --git a/src/smpi/private.h b/src/smpi/private.h index 91d84892bb..4816283321 100644 --- a/src/smpi/private.h +++ b/src/smpi/private.h @@ -47,6 +47,8 @@ smpi_process_data_t smpi_process_remote_data(int index); int smpi_process_count(void); int smpi_process_index(void); xbt_os_timer_t smpi_process_timer(void); +void smpi_process_simulated_start(void); +double smpi_process_simulated_elapsed(void); void print_request(const char* message, MPI_Request request); void smpi_process_post_send(MPI_Comm comm, MPI_Request request); void smpi_process_post_recv(MPI_Request request); diff --git a/src/smpi/smpi_bench.c b/src/smpi/smpi_bench.c index 113121da3c..3608df626a 100644 --- a/src/smpi/smpi_bench.c +++ b/src/smpi/smpi_bench.c @@ -12,20 +12,27 @@ XBT_LOG_NEW_DEFAULT_SUBCATEGORY(smpi_bench, smpi, "Logging specific to SMPI (benchmarking)"); xbt_dict_t allocs = NULL; /* Allocated on first use */ +xbt_dict_t samples = NULL; /* Allocated on first use */ typedef struct { int count; char data[]; } shared_data_t; -static void free_shared_data(void* ptr) { - free(ptr); -} +typedef struct { + double time; + int count; + int max; + int started; +} local_data_t; void smpi_bench_destroy(void) { if (allocs) { xbt_dict_free(&allocs); } + if (samples) { + xbt_dict_free(&samples); + } } static void smpi_execute(double duration) { @@ -74,54 +81,89 @@ void smpi_bench_end(int rank, const char* mpi_call) { } } -/* -TODO -void smpi_do_once_1(const char *file, int line) -{ - smpi_do_once_duration_node_t curr, prev; - - smpi_bench_end(); - SIMIX_mutex_lock(smpi_global->do_once_mutex); - prev = NULL; - for(curr = smpi_global->do_once_duration_nodes; - NULL != curr && (strcmp(curr->file, file) || curr->line != line); - curr = curr->next) { - prev = curr; - } - if(NULL == curr) { - curr = xbt_new(s_smpi_do_once_duration_node_t, 1); - curr->file = xbt_strdup(file); - curr->line = line; - curr->duration = -1; - curr->next = NULL; - if(NULL == prev) { - smpi_global->do_once_duration_nodes = curr; - } else { - prev->next = curr; - } - } - smpi_global->do_once_duration = &curr->duration; +unsigned int smpi_sleep(unsigned int secs) { + smpi_execute((double)secs); } -int smpi_do_once_2() -{ - double duration = *(smpi_global->do_once_duration); +int smpi_gettimeofday(struct timeval* tv, struct timezone* tz) { + double now = SIMIX_get_clock(); - if(0 > duration) { - smpi_start_timer(); - return 1; - } - SIMIX_mutex_unlock(smpi_global->do_once_mutex); - smpi_execute(duration); - smpi_bench_begin(); - return 0; + if(tv) { + tv->tv_sec = (time_t)now; + tv->tv_usec = (suseconds_t)(now * 1e6); + } + return 0; +} + +static char* sample_location(int global, const char* file, int line) { + if(global) { + return bprintf("%s:%d", file, line); + } else { + return bprintf("%s:%d:%d", file, line, smpi_process_index()); + } +} + +void smpi_sample_1(int global, const char* file, int line, int max) { + char* loc = sample_location(global, file, line); + local_data_t* data; + + smpi_bench_end(-1, NULL); /* 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->time = 0.0; + data->count = 0; + data->max = max; + data->started = 0; + xbt_dict_set(samples, loc, data, &free); + } + free(loc); } -void smpi_do_once_3() -{ - *(smpi_global->do_once_duration) = smpi_stop_timer(); +int smpi_sample_2(int global, const char* file, int line) { + char* loc = sample_location(global, file, line); + local_data_t* data; + double* simu; + + xbt_assert0(samples, "You did something very inconsistent, didn't you?"); + data = xbt_dict_get_or_null(samples, loc); + if (!data) { + xbt_assert0(data, "Please, do thing in order"); + } + if (!data->started) { + if (data->count < data->max) { + data->started = 1; + data->count++; + } else { + DEBUG1("Perform some wait of %f", data->time / (double)data->count); + smpi_execute(data->time / (double)data->count); + } + } else { + data->started = 0; + } + free(loc); + smpi_bench_begin(-1, NULL); + 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 spent; + + xbt_assert0(samples, "You did something very inconsistent, didn't you?"); + data = xbt_dict_get_or_null(samples, loc); + if (!data || !data->started || data->count >= data->max) { + xbt_assert0(data, "Please, do thing in order"); + } + smpi_bench_end(-1, NULL); + data->time += smpi_process_simulated_elapsed(); + DEBUG2("Average mean after %d steps is %f", data->count, data->time / (double)data->count); } -*/ void* smpi_shared_malloc(size_t size, const char* file, int line) { char* loc = bprintf("%s:%d:%zu", file, line, size); @@ -134,7 +176,7 @@ void* smpi_shared_malloc(size_t size, const char* file, int line) { if (!data) { data = (shared_data_t*)xbt_malloc0(sizeof(int) + size); data->count = 1; - xbt_dict_set(allocs, loc, data, &free_shared_data); + xbt_dict_set(allocs, loc, data, &free); } else { data->count++; } diff --git a/src/smpi/smpi_global.c b/src/smpi/smpi_global.c index 55e4894312..92ab45b1fb 100644 --- a/src/smpi/smpi_global.c +++ b/src/smpi/smpi_global.c @@ -20,6 +20,7 @@ typedef struct s_smpi_process_data { xbt_fifo_t pending_sent; xbt_fifo_t pending_recv; xbt_os_timer_t timer; + double simulated; MPI_Comm comm_self; } s_smpi_process_data_t; @@ -52,6 +53,18 @@ xbt_os_timer_t smpi_process_timer(void) { return data->timer; } +void smpi_process_simulated_start(void) { + smpi_process_data_t data = smpi_process_data(); + + data->simulated = SIMIX_get_clock(); +} + +double smpi_process_simulated_elapsed(void) { + smpi_process_data_t data = smpi_process_data(); + + return SIMIX_get_clock() - data->simulated; +} + MPI_Comm smpi_process_comm_self(void) { smpi_process_data_t data = smpi_process_data(); -- 2.20.1