Take size into account when building a unique name.

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

diff --git a/src/smpi/smpi_bench.c b/src/smpi/smpi_bench.c
index c15fc35..113121d 100644 (file)
--- a/src/smpi/smpi_bench.c
+++ b/src/smpi/smpi_bench.c
@@ -1,30 +1,52 @@
+/* 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 <string.h>
+#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)
-{
+xbt_dict_t allocs = NULL; /* Allocated on first use */
+
+typedef struct {
+   int count;
+   char data[];
+} shared_data_t;
+
+static void free_shared_data(void* ptr) {
+   free(ptr);
+}
+
+void smpi_bench_destroy(void) {
+   if (allocs) {
+      xbt_dict_free(&allocs);
+   }
+}
+
+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 > 0.001) {
+  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, "reference_speed");
-    action = SIMIX_action_sleep(host, 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)) {
+    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);
@@ -35,17 +57,21 @@ void smpi_execute(double duration)
   }
 }
 
-void smpi_bench_begin()
-{
+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()
-{
+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);
+  }
 }
 
 /*
@@ -96,3 +122,41 @@ 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);
+   }
+}