X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/401273041d310cd9077459a90fc18aa0361b034c..158d49db67f6eabca7de5d4c8b44ffa9c9b946f6:/src/smpi/smpi_bench.c

diff --git a/src/smpi/smpi_bench.c b/src/smpi/smpi_bench.c
index 8376fa4bfa..bdc0055522 100644
--- a/src/smpi/smpi_bench.c
+++ b/src/smpi/smpi_bench.c
@@ -126,19 +126,31 @@ void smpi_bench_destroy(void)
   xbt_dict_free(&calls);
 }
 
+XBT_PUBLIC(void) smpi_execute_flops_(double *flops);
+void smpi_execute_flops_(double *flops)
+{
+  smpi_execute_flops(*flops);
+}
+
+XBT_PUBLIC(void) smpi_execute_(double *duration);
+void smpi_execute_(double *duration)
+{
+  smpi_execute(*duration);
+}
+
 void smpi_execute_flops(double flops) {
   smx_action_t action;
   smx_host_t host;
   host = SIMIX_host_self();
-  XBT_DEBUG("Handle real computation time: %g flops", flops);
-  action = simcall_host_execute("computation", host, flops, 1);
+  XBT_DEBUG("Handle real computation time: %f flops", flops);
+  action = simcall_host_execute("computation", host, flops, 1, 0, 0);
 #ifdef HAVE_TRACING
   simcall_set_category (action, TRACE_internal_smpi_get_category());
 #endif
   simcall_host_execution_wait(action);
 }
 
-static void smpi_execute(double duration)
+void smpi_execute(double duration)
 {
   if (duration >= smpi_cpu_threshold) {
     XBT_DEBUG("Sleep for %g to handle real computation time", duration);
@@ -171,8 +183,13 @@ void smpi_bench_begin(void)
 void smpi_bench_end(void)
 {
   xbt_os_timer_t timer = smpi_process_timer();
-
   xbt_os_threadtimer_stop(timer);
+  if (smpi_process_get_sampling()) {
+    XBT_CRITICAL("Cannot do recursive benchmarks.");
+    XBT_CRITICAL("Are you trying to make a call to MPI within a SMPI_SAMPLE_ block?");
+    xbt_backtrace_display_current();
+    xbt_die("Aborting.");
+  }
   smpi_execute(xbt_os_timer_elapsed(timer));
 }
 
@@ -184,7 +201,7 @@ unsigned int smpi_sleep(unsigned int secs)
 
   double flops = (double) secs*simcall_host_get_speed(SIMIX_host_self());
   XBT_DEBUG("Sleep for: %f flops", flops);
-  action = simcall_host_execute("computation", SIMIX_host_self(), flops, 1);
+  action = simcall_host_execute("computation", SIMIX_host_self(), flops, 1, 0, 0);
   #ifdef HAVE_TRACING
     simcall_set_category (action, TRACE_internal_smpi_get_category());
   #endif
@@ -243,8 +260,6 @@ typedef struct {
   int benching;     /* 1: we are benchmarking; 0: we have enough data, no bench anymore */
 } local_data_t;
 
-int smpi_sample_is_running = 0;
-
 static char *sample_location(int global, const char *file, int line) {
   if (global) {
     return bprintf("%s:%d", file, line);
@@ -272,7 +287,7 @@ void smpi_sample_1(int global, const char *file, int line, int iters, double thr
   local_data_t *data;
 
   smpi_bench_end();     /* Take time from previous, unrelated computation into account */
-  smpi_sample_is_running++;
+  smpi_process_set_sampling(1);
 
   if (!samples)
     samples = xbt_dict_new_homogeneous(free);
@@ -309,6 +324,7 @@ int smpi_sample_2(int global, const char *file, int line)
 {
   char *loc = sample_location(global, file, line);
   local_data_t *data;
+  int res;
 
   xbt_assert(samples, "Y U NO use SMPI_SAMPLE_* macros? Stop messing directly with smpi_sample_* functions!");
   data = xbt_dict_get(samples, loc);
@@ -319,19 +335,18 @@ int smpi_sample_2(int global, const char *file, int line)
     // 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;
+    res = 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_sample_is_running--;
-    smpi_bench_begin(); // prepare to capture future, unrelated computations
-    return 0;
+    smpi_process_set_sampling(0);
+    res = 0; // prepare to capture future, unrelated computations
   }
+  smpi_bench_begin();
+  return res;
 }
 
 
@@ -493,28 +508,28 @@ void smpi_shared_free(void *ptr)
 }
 #endif
 
-int smpi_shared_known_call(const char* func, const char* input) {
-   char* loc = bprintf("%s:%s", func, input);
-   xbt_ex_t ex;
-   int known;
+int smpi_shared_known_call(const char* func, const char* input)
+{
+  char* loc = bprintf("%s:%s", func, input);
+  xbt_ex_t ex;
+  int known = 0;
 
-   if(!calls) {
-      calls = xbt_dict_new_homogeneous(NULL);
-   }
-   TRY {
-      xbt_dict_get(calls, loc); /* Succeed or throw */
-      known = 1;
-   }
-   CATCH(ex) {
-      if(ex.category == not_found_error) {
-         known = 0;
-         xbt_ex_free(ex);
-      } else {
-         RETHROW;
-      }
-   }
-   free(loc);
-   return known;
+  if (!calls) {
+    calls = xbt_dict_new_homogeneous(NULL);
+  }
+  TRY {
+    xbt_dict_get(calls, loc); /* Succeed or throw */
+    known = 1;
+  }
+  TRY_CLEANUP {
+    xbt_free(loc);
+  }
+  CATCH(ex) {
+    if (ex.category != not_found_error)
+      RETHROW;
+    xbt_ex_free(ex);
+  }
+  return known;
 }
 
 void* smpi_shared_get_call(const char* func, const char* input) {