Use CommImpl* for comm_copy callbacks.

[simgrid.git] / src / smpi / internals / smpi_global.cpp

diff --git a/src/smpi/internals/smpi_global.cpp b/src/smpi/internals/smpi_global.cpp
index 96282f0..61f16b1 100644 (file)
--- a/src/smpi/internals/smpi_global.cpp
+++ b/src/smpi/internals/smpi_global.cpp
@@ -102,7 +102,8 @@ static const std::string smpi_default_instance_name("smpirun");
 static simgrid::config::Flag<double> smpi_init_sleep(
   "smpi/init", "Time to inject inside a call to MPI_Init", 0.0);
 
-void (*smpi_comm_copy_data_callback) (smx_activity_t, void*, size_t) = &smpi_comm_copy_buffer_callback;
+void (*smpi_comm_copy_data_callback)(simgrid::kernel::activity::CommImpl*, void*,
+                                     size_t) = &smpi_comm_copy_buffer_callback;
 
 int smpi_process_count()
 {
@@ -151,7 +152,11 @@ int smpi_global_size()
 
 void smpi_comm_set_copy_data_callback(void (*callback) (smx_activity_t, void*, size_t))
 {
-  smpi_comm_copy_data_callback = callback;
+  static void (*saved_callback)(smx_activity_t, void*, size_t);
+  saved_callback               = callback;
+  smpi_comm_copy_data_callback = [](simgrid::kernel::activity::CommImpl* comm, void* buff, size_t size) {
+    saved_callback(smx_activity_t(comm), buff, size);
+  };
 }
 
 static void memcpy_private(void* dest, const void* src, std::vector<std::pair<size_t, size_t>>& private_blocks)
@@ -165,10 +170,8 @@ static void check_blocks(std::vector<std::pair<size_t, size_t>> &private_blocks,
     xbt_assert(block.first <= block.second && block.second <= buff_size, "Oops, bug in shared malloc.");
 }
 
-void smpi_comm_copy_buffer_callback(smx_activity_t synchro, void *buff, size_t buff_size)
+void smpi_comm_copy_buffer_callback(simgrid::kernel::activity::CommImpl* comm, void* buff, size_t buff_size)
 {
-  simgrid::kernel::activity::CommImplPtr comm =
-      boost::dynamic_pointer_cast<simgrid::kernel::activity::CommImpl>(synchro);
   int src_shared                        = 0;
   int dst_shared                        = 0;
   size_t src_offset                     = 0;
@@ -227,7 +230,7 @@ void smpi_comm_copy_buffer_callback(smx_activity_t synchro, void *buff, size_t b
     xbt_free(tmpbuff);
 }
 
-void smpi_comm_null_copy_buffer_callback(smx_activity_t comm, void *buff, size_t buff_size)
+void smpi_comm_null_copy_buffer_callback(simgrid::kernel::activity::CommImpl*, void*, size_t)
 {
   /* nothing done in this version */
 }
@@ -488,7 +491,7 @@ static smpi_entry_point_type smpi_resolve_function(void* handle)
   return smpi_entry_point_type();
 }
 
-static void smpi_copy_file(std::string src, std::string target, off_t fdin_size)
+static void smpi_copy_file(const std::string& src, const std::string& target, off_t fdin_size)
 {
   int fdin = open(src.c_str(), O_RDONLY);
   xbt_assert(fdin >= 0, "Cannot read from %s. Please make sure that the file exists and is executable.", src.c_str());
@@ -498,28 +501,30 @@ static void smpi_copy_file(std::string src, std::string target, off_t fdin_size)
   XBT_DEBUG("Copy %" PRIdMAX " bytes into %s", static_cast<intmax_t>(fdin_size), target.c_str());
 #if SG_HAVE_SENDFILE
   ssize_t sent_size = sendfile(fdout, fdin, NULL, fdin_size);
-  xbt_assert(sent_size == fdin_size || (sent_size == -1 && errno == ENOSYS),
-             "Error while copying %s: only %zd bytes copied instead of %" PRIdMAX " (errno: %d -- %s)", target.c_str(),
-             sent_size, static_cast<intmax_t>(fdin_size), errno, strerror(errno));
-#else
-  ssize_t sent_size = -1;
+  if (sent_size == fdin_size) {
+    close(fdin);
+    close(fdout);
+    return;
+  } else if (sent_size != -1 || errno != ENOSYS) {
+    xbt_die("Error while copying %s: only %zd bytes copied instead of %" PRIdMAX " (errno: %d -- %s)", target.c_str(),
+            sent_size, static_cast<intmax_t>(fdin_size), errno, strerror(errno));
+  }
 #endif
-  if (sent_size != fdin_size) { // sendfile is not available
-    const int bufsize = 1024 * 1024 * 4;
-    char buf[bufsize];
-    while (int got = read(fdin, buf, bufsize)) {
-      if (got == -1) {
-        xbt_assert(errno == EINTR, "Cannot read from %s", src.c_str());
-      } else {
-        char* p  = buf;
-        int todo = got;
-        while (int done = write(fdout, p, todo)) {
-          if (done == -1) {
-            xbt_assert(errno == EINTR, "Cannot write into %s", target.c_str());
-          } else {
-            p += done;
-            todo -= done;
-          }
+  // If this point is reached, sendfile() actually is not available.  Copy file by hand.
+  const int bufsize = 1024 * 1024 * 4;
+  char buf[bufsize];
+  while (int got = read(fdin, buf, bufsize)) {
+    if (got == -1) {
+      xbt_assert(errno == EINTR, "Cannot read from %s", src.c_str());
+    } else {
+      char* p  = buf;
+      int todo = got;
+      while (int done = write(fdout, p, todo)) {
+        if (done == -1) {
+          xbt_assert(errno == EINTR, "Cannot write into %s", target.c_str());
+        } else {
+          p += done;
+          todo -= done;
         }
       }
     }