X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/dff9e15c44ab6340d27215957c56fa72fad246a2..3b370827ee7e9a105556091d2b53a73acca25d7b:/src/smpi/smpi_bench.c diff --git a/src/smpi/smpi_bench.c b/src/smpi/smpi_bench.c index ec81226b69..113121da3c 100644 --- a/src/smpi/smpi_bench.c +++ b/src/smpi/smpi_bench.c @@ -1,80 +1,100 @@ +/* Copyright (c) 2007, 2009, 2010. 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. */ + #include "private.h" -#include +#include "xbt/dict.h" +#include "xbt/sysdep.h" XBT_LOG_NEW_DEFAULT_SUBCATEGORY(smpi_bench, smpi, "Logging specific to SMPI (benchmarking)"); -void smpi_execute(double duration) -{ - smx_host_t host = SIMIX_host_self(); - smx_mutex_t mutex = smpi_host_mutex(); - smx_cond_t cond = smpi_host_cond(); - smx_action_t action; - e_surf_action_state_t state; - - SIMIX_mutex_lock(mutex); +xbt_dict_t allocs = NULL; /* Allocated on first use */ - action = - SIMIX_action_execute(host, "execute", duration * SMPI_DEFAULT_SPEED); - - SIMIX_register_action_to_condition(action, cond); - for (state = SIMIX_action_get_state(action); - state == SURF_ACTION_READY || - state == SURF_ACTION_RUNNING; state = SIMIX_action_get_state(action) - ) { - SIMIX_cond_wait(cond, mutex); - } - SIMIX_unregister_action_to_condition(action, cond); - SIMIX_action_destroy(action); +typedef struct { + int count; + char data[]; +} shared_data_t; - SIMIX_mutex_unlock(mutex); - - return; +static void free_shared_data(void* ptr) { + free(ptr); } -void smpi_start_timer() -{ - SIMIX_mutex_lock(smpi_global->timer_mutex); - xbt_os_timer_start(smpi_global->timer); +void smpi_bench_destroy(void) { + if (allocs) { + xbt_dict_free(&allocs); + } } -double smpi_stop_timer() -{ - double duration; - xbt_os_timer_stop(smpi_global->timer); - duration = xbt_os_timer_elapsed(smpi_global->timer); - SIMIX_mutex_unlock(smpi_global->timer_mutex); - return duration; +static void smpi_execute(double duration) { + smx_host_t host; + smx_action_t action; + smx_mutex_t mutex; + smx_cond_t cond; + e_surf_action_state_t state; + + if(duration >= xbt_cfg_get_double(_surf_cfg_set, "smpi/cpu_threshold")) { + host = SIMIX_host_self(); + mutex = SIMIX_mutex_init(); + cond = SIMIX_cond_init(); + DEBUG1("Sleep for %f to handle real computation time", duration); + duration *= xbt_cfg_get_double(_surf_cfg_set, "smpi/running_power"); + action = SIMIX_action_execute(host, "computation", duration); + SIMIX_mutex_lock(mutex); + SIMIX_register_action_to_condition(action, cond); + for(state = SIMIX_action_get_state(action); + state == SURF_ACTION_READY || + state == SURF_ACTION_RUNNING; state = SIMIX_action_get_state(action)) { + SIMIX_cond_wait(cond, mutex); + } + SIMIX_unregister_action_to_condition(action, cond); + SIMIX_mutex_unlock(mutex); + SIMIX_action_destroy(action); + SIMIX_cond_destroy(cond); + SIMIX_mutex_destroy(mutex); + } } -void smpi_bench_begin() -{ - smpi_start_timer(); +void smpi_bench_begin(int rank, const char* mpi_call) { + if(mpi_call && rank >= 0 && xbt_cfg_get_int(_surf_cfg_set, "smpi/log_events")) { + INFO3("SMPE: ts=%f rank=%d type=end et=%s", SIMIX_get_clock(), rank, mpi_call); + } + xbt_os_timer_start(smpi_process_timer()); } -void smpi_bench_end() -{ - smpi_execute(smpi_stop_timer()); +void smpi_bench_end(int rank, const char* mpi_call) { + xbt_os_timer_t timer = smpi_process_timer(); + + xbt_os_timer_stop(timer); + smpi_execute(xbt_os_timer_elapsed(timer)); + if(mpi_call && rank >= 0 && xbt_cfg_get_int(_surf_cfg_set, "smpi/log_events")) { + INFO3("SMPE: ts=%f rank=%d type=begin et=%s", SIMIX_get_clock(), rank, 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) { + 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) { + 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) { + if(NULL == prev) { smpi_global->do_once_duration_nodes = curr; } else { prev->next = curr; @@ -86,7 +106,8 @@ void smpi_do_once_1(const char *file, int line) int smpi_do_once_2() { double duration = *(smpi_global->do_once_duration); - if (0 > duration) { + + if(0 > duration) { smpi_start_timer(); return 1; } @@ -100,3 +121,42 @@ void smpi_do_once_3() { *(smpi_global->do_once_duration) = smpi_stop_timer(); } +*/ + +void* smpi_shared_malloc(size_t size, const char* file, int line) { + char* loc = bprintf("%s:%d:%zu", file, line, size); + shared_data_t* data; + + if (!allocs) { + allocs = xbt_dict_new(); + } + data = xbt_dict_get_or_null(allocs, loc); + if (!data) { + data = (shared_data_t*)xbt_malloc0(sizeof(int) + size); + data->count = 1; + xbt_dict_set(allocs, loc, data, &free_shared_data); + } else { + data->count++; + } + free(loc); + return data->data; +} + +void smpi_shared_free(void* ptr) { + shared_data_t* data = (shared_data_t*)((int*)ptr - 1); + char* loc; + + if (!allocs) { + WARN0("Cannot free: nothing was allocated"); + return; + } + loc = xbt_dict_get_key(allocs, data); + if (!loc) { + WARN1("Cannot free: %p was not shared-allocated by SMPI", ptr); + return; + } + data->count--; + if (data->count <= 0) { + xbt_dict_remove(allocs, loc); + } +}