Copy the name of the "file", as we don't know where it comes from.

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

diff --git a/src/smpi/smpi_bench.cpp b/src/smpi/smpi_bench.cpp
index e9b4773..adbbd3d 100644 (file)
--- a/src/smpi/smpi_bench.cpp
+++ b/src/smpi/smpi_bench.cpp
@@ -12,6 +12,7 @@
 #include "src/internal_config.h"
 #include "private.h"
 #include "private.hpp"
+#include <xbt/ex.hpp>
 #include "xbt/dict.h"
 #include "xbt/sysdep.h"
 #include "xbt/ex.h"
@@ -32,6 +33,10 @@
 #include <string.h>
 #include <stdio.h>
 
+#if HAVE_PAPI
+#include <papi.h>
+#endif
+
 #ifndef MAP_ANONYMOUS
 #define MAP_ANONYMOUS MAP_ANON
 #endif
@@ -93,10 +98,10 @@ namespace {
 class smpi_source_location {
 public:
   smpi_source_location(const char* filename, int line)
-    : filename(filename), filename_length(strlen(filename)), line(line) {}
+    : filename(xbt_strdup(filename)), filename_length(strlen(filename)), line(line) {}
 
   /** Pointer to a static string containing the file name */
-  const char* filename = nullptr;
+  char* filename = nullptr;
   int filename_length = 0;
   int line = 0;
 
@@ -170,7 +175,7 @@ static void* shm_map(int fd, size_t size, shared_data_key_type* data) {
 
   mem = mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
   if(mem == MAP_FAILED) {
-    xbt_die("Could not map fd %d: %s", fd, strerror(errno));
+    xbt_die("Could not map fd %d with size %zu: %s", fd, size, strerror(errno));
   }
   snprintf(loc, PTR_STRLEN, "%p", mem);
   meta.size = size;
@@ -239,18 +244,54 @@ void smpi_bench_begin(void)
   if (MC_is_active() || MC_record_replay_is_active())
     return;
 
+#if HAVE_PAPI
+  if (xbt_cfg_get_string("smpi/papi-events")[0] != '\0') {
+    int event_set = smpi_process_papi_event_set();
+    // PAPI_start sets everything to 0! See man(3) PAPI_start
+    if (PAPI_LOW_LEVEL_INITED == PAPI_is_initialized()) {
+      if (PAPI_start(event_set) != PAPI_OK) {
+        // TODO This needs some proper handling.
+        XBT_CRITICAL("Could not start PAPI counters.\n");
+        xbt_die("Error.");
+      }
+    }
+  }
+#endif
   xbt_os_threadtimer_start(smpi_process_timer());
 }
 
 void smpi_bench_end(void)
 {
-
   if (MC_is_active() || MC_record_replay_is_active())
     return;
 
   double speedup = 1;
   xbt_os_timer_t timer = smpi_process_timer();
   xbt_os_threadtimer_stop(timer);
+
+#if HAVE_PAPI
+  /**
+   * An MPI function has been called and now is the right time to update
+   * our PAPI counters for this process.
+   */
+  if (xbt_cfg_get_string("smpi/papi-events")[0] != '\0') {
+    papi_counter_t& counter_data        = smpi_process_papi_counters();
+    int event_set                       = smpi_process_papi_event_set();
+    std::vector<long long> event_values = std::vector<long long>(counter_data.size());
+
+    if (PAPI_stop(event_set, &event_values[0]) != PAPI_OK) { // Error
+      XBT_CRITICAL("Could not stop PAPI counters.\n");
+      xbt_die("Error.");
+    } else {
+      for (unsigned int i = 0; i < counter_data.size(); i++) {
+        counter_data[i].second += event_values[i];
+        // XBT_DEBUG("[%i] PAPI: Counter %s: Value is now %lli (got increment by %lli\n", smpi_process_index(),
+        // counter_data[i].first.c_str(), counter_data[i].second, event_values[i]);
+      }
+    }
+  }
+#endif
+
   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?");
@@ -274,6 +315,20 @@ void smpi_bench_end(void)
     smpi_execute(xbt_os_timer_elapsed(timer)/speedup);
   }
 
+#if HAVE_PAPI
+  if (xbt_cfg_get_string("smpi/papi-events")[0] != '\0' && TRACE_smpi_is_enabled()) {
+    char container_name[INSTR_DEFAULT_STR_SIZE];
+    smpi_container(smpi_process_index(), container_name, INSTR_DEFAULT_STR_SIZE);
+    container_t container        = PJ_container_get(container_name);
+    papi_counter_t& counter_data = smpi_process_papi_counters();
+
+    for (auto& pair : counter_data) {
+      new_pajeSetVariable(surf_get_clock(), container,
+                          PJ_type_get(/* countername */ pair.first.c_str(), container->type), pair.second);
+    }
+  }
+#endif
+
   smpi_total_benched_time += xbt_os_timer_elapsed(timer);
 }
 
@@ -513,7 +568,7 @@ void smpi_sample_3(int global, const char *file, int line)
 void *smpi_shared_malloc(size_t size, const char *file, int line)
 {
   void* mem;
-  if (xbt_cfg_get_boolean("smpi/use-shared-malloc")){
+  if (size > 0 && xbt_cfg_get_boolean("smpi/use-shared-malloc")){
     int fd;
     smpi_source_location loc(file, line);
     auto res = allocs.insert(std::make_pair(loc, shared_data_t()));
@@ -558,7 +613,7 @@ void smpi_shared_free(void *ptr)
     snprintf(loc, PTR_STRLEN, "%p", ptr);
     auto meta = allocs_metadata.find(ptr);
     if (meta == allocs_metadata.end()) {
-      XBT_WARN("Cannot free: %p was not shared-allocated by SMPI", ptr);
+      XBT_WARN("Cannot free: %p was not shared-allocated by SMPI - maybe its size was 0?", ptr);
       return;
     }
     shared_data_t* data = &meta->second.data->second;
@@ -566,11 +621,12 @@ void smpi_shared_free(void *ptr)
       XBT_WARN("Unmapping of fd %d failed: %s", data->fd, strerror(errno));
     }
     data->count--;
-    XBT_DEBUG("Shared free - no removal - of %p, count = %d", ptr, data->count);
     if (data->count <= 0) {
       close(data->fd);
       allocs.erase(allocs.find(meta->second.data->first));
       XBT_DEBUG("Shared free - with removal - of %p", ptr);
+    }else{
+      XBT_DEBUG("Shared free - no removal - of %p, count = %d", ptr, data->count);
     }
   }else{
     XBT_DEBUG("Classic free of %p", ptr);