made some changes to allow more than one DO_ONCE block. also fixed bug in

[simgrid.git] / src / smpi / smpi_bench.c

diff --git a/src/smpi/smpi_bench.c b/src/smpi/smpi_bench.c
index 81ed0f0..6bb7a8d 100644 (file)
--- a/src/smpi/smpi_bench.c
+++ b/src/smpi/smpi_bench.c
@@ -1,79 +1,86 @@
-#include <stdio.h>
 #include "private.h"
+#include <string.h>
 
-// FIXME: could cause trouble with multithreaded procs on same host...
-// FIXME: add benchmarking flag?
+void smpi_execute(double duration) {
+        smx_host_t host = SIMIX_host_self();
+        smx_action_t action;
 
-void smpi_bench_begin()
-{
-       SIMIX_mutex_lock(smpi_global->timer_mutex);
+       SIMIX_mutex_lock(smpi_global->execute_mutex);
 
-       xbt_os_timer_start(smpi_global->timer);
+       action = SIMIX_action_execute(host, "execute", duration * SMPI_DEFAULT_SPEED);
+
+        SIMIX_register_action_to_condition(action, smpi_global->execute_cond);
+        SIMIX_cond_wait(smpi_global->execute_cond, smpi_global->execute_mutex);
+        SIMIX_unregister_action_to_condition(action, smpi_global->execute_cond);
+        SIMIX_action_destroy(action);
+
+        SIMIX_mutex_unlock(smpi_global->execute_mutex);
 
        return;
 }
 
-double smpi_bench_end()
+void smpi_start_timer()
 {
-       double duration;
-       smx_host_t host;
-       smx_action_t action;
+       SIMIX_mutex_lock(smpi_global->timer_mutex);
+       xbt_os_timer_start(smpi_global->timer);
+}
 
+double smpi_stop_timer()
+{
+       double duration;
        xbt_os_timer_stop(smpi_global->timer);
-
        duration = xbt_os_timer_elapsed(smpi_global->timer);
-
-       host     = SIMIX_host_self();
-       action   = SIMIX_action_execute(host, "computation", duration * SMPI_DEFAULT_SPEED);
-
-       SIMIX_register_action_to_condition(action, smpi_global->timer_cond);
-       SIMIX_cond_wait(smpi_global->timer_cond, smpi_global->timer_mutex);
-       SIMIX_unregister_action_to_condition(action, smpi_global->timer_cond);
-
        SIMIX_mutex_unlock(smpi_global->timer_mutex);
-
        return duration;
 }
 
-void smpi_bench_skip() {
-       smx_host_t host;
-       smx_action_t action;
-       double duration = smpi_global->times[0];
-
-       SIMIX_mutex_lock(smpi_global->timer_mutex);
-
-       host   = SIMIX_host_self();
-        action = SIMIX_action_execute(host, "computation", duration * SMPI_DEFAULT_SPEED);
-
-       SIMIX_register_action_to_condition(action, smpi_global->timer_cond);
-       SIMIX_cond_wait(smpi_global->timer_cond, smpi_global->timer_mutex);
-       SIMIX_unregister_action_to_condition(action, smpi_global->timer_cond);
-
-       SIMIX_mutex_unlock(smpi_global->timer_mutex);
+void smpi_bench_begin()
+{
+       smpi_start_timer();
+}
 
-       return;
+void smpi_bench_end()
+{
+       smpi_execute(smpi_stop_timer());
 }
 
-void smpi_do_once_1() {
+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->times_mutex);
-       if (0 < smpi_global->times[0]) {
-               smpi_bench_skip();
+       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;
        }
-       return;
+       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;
 }
 
 int smpi_do_once_2() {
-       int retval = 1;
-       if (0 < smpi_global->times[0]) {
-               SIMIX_mutex_unlock(smpi_global->times_mutex);
-               retval = 0;
+       double duration = *(smpi_global->do_once_duration);
+       if (0 < duration) {
+               SIMIX_mutex_unlock(smpi_global->do_once_mutex);
+               smpi_execute(duration);
+               smpi_bench_begin();
+               return 0;
        }
-       smpi_bench_begin();
-       return retval;
+       smpi_start_timer();
+       return 1;
 }
 
 void smpi_do_once_3() {
-       smpi_global->times[0] = smpi_bench_end();
-       return;
+       *(smpi_global->do_once_duration) = smpi_stop_timer();
 }