Avoid unnecessary copy of parameters for parallel_execute.

diff --git a/include/simgrid/s4u/Actor.hpp b/include/simgrid/s4u/Actor.hpp
index e9cc96b..3b1cffa 100644 (file)
--- a/include/simgrid/s4u/Actor.hpp
+++ b/include/simgrid/s4u/Actor.hpp
@@ -469,22 +469,23 @@ XBT_PUBLIC void execute(double flop, double priority);
  *
  * \endrst
  */
-XBT_PUBLIC void parallel_execute(std::vector<s4u::Host*> hosts, std::vector<double> flops_amounts,
-                                 std::vector<double> bytes_amounts);
+XBT_PUBLIC void parallel_execute(const std::vector<s4u::Host*>& hosts, const std::vector<double>& flops_amounts,
+                                 const std::vector<double>& bytes_amounts);
 
 /** \rst
  * Block the current actor until the built :ref:`parallel execution <API_s4u_parallel_execute>` completes, or until the
  * timeout. \endrst
  */
-XBT_PUBLIC void parallel_execute(std::vector<s4u::Host*> hosts, std::vector<double> flops_amounts,
-                                 std::vector<double> bytes_amounts, double timeout);
+XBT_PUBLIC void parallel_execute(const std::vector<s4u::Host*>& hosts, const std::vector<double>& flops_amounts,
+                                 const std::vector<double>& bytes_amounts, double timeout);
 
 #ifndef DOXYGEN
 XBT_ATTRIB_DEPRECATED_v325("Please use std::vectors as parameters") XBT_PUBLIC
-    void parallel_execute(int host_nb, s4u::Host** host_list, double* flops_amount, double* bytes_amount);
+    void parallel_execute(int host_nb, s4u::Host* const* host_list, const double* flops_amount,
+                          const double* bytes_amount);
 XBT_ATTRIB_DEPRECATED_v325("Please use std::vectors as parameters") XBT_PUBLIC
-    void parallel_execute(int host_nb, s4u::Host** host_list, double* flops_amount, double* bytes_amount,
-                          double timeout);
+    void parallel_execute(int host_nb, s4u::Host* const* host_list, const double* flops_amount,
+                          const double* bytes_amount, double timeout);
 #endif
 
 XBT_PUBLIC ExecPtr exec_init(double flops_amounts);

diff --git a/include/simgrid/simix.h b/include/simgrid/simix.h
index 952f10b..2c53a01 100644 (file)
--- a/include/simgrid/simix.h
+++ b/include/simgrid/simix.h
@@ -176,9 +176,9 @@ XBT_PUBLIC void SIMIX_comm_finish(smx_activity_t synchro);
 
 /******************************* Host simcalls ********************************/
 #ifdef __cplusplus
-XBT_PUBLIC smx_activity_t simcall_execution_parallel_start(std::string name, int host_nb, sg_host_t* host_list,
-                                                           double* flops_amount, double* bytes_amount, double rate,
-                                                           double timeout);
+XBT_PUBLIC smx_activity_t simcall_execution_parallel_start(const std::string& name, int host_nb,
+                                                           const sg_host_t* host_list, const double* flops_amount,
+                                                           const double* bytes_amount, double rate, double timeout);
 #endif
 XBT_PUBLIC e_smx_state_t simcall_execution_wait(smx_activity_t execution);
 XBT_PUBLIC e_smx_state_t simcall_execution_test(smx_activity_t execution);

diff --git a/src/s4u/s4u_Actor.cpp b/src/s4u/s4u_Actor.cpp
index 15af517..ec1085f 100644 (file)
--- a/src/s4u/s4u_Actor.cpp
+++ b/src/s4u/s4u_Actor.cpp
@@ -295,13 +295,13 @@ void execute(double flops, double priority)
   exec_init(flops)->set_priority(priority)->start()->wait();
 }
 
-void parallel_execute(std::vector<s4u::Host*> hosts, std::vector<double> flops_amounts,
-                      std::vector<double> bytes_amounts)
+void parallel_execute(const std::vector<s4u::Host*>& hosts, const std::vector<double>& flops_amounts,
+                      const std::vector<double>& bytes_amounts)
 {
   parallel_execute(hosts, flops_amounts, bytes_amounts, -1);
 }
-void parallel_execute(std::vector<s4u::Host*> hosts, std::vector<double> flops_amounts,
-                      std::vector<double> bytes_amounts, double timeout)
+void parallel_execute(const std::vector<s4u::Host*>& hosts, const std::vector<double>& flops_amounts,
+                      const std::vector<double>& bytes_amounts, double timeout)
 {
   xbt_assert(hosts.size() > 0, "Your parallel executions must span over at least one host.");
   xbt_assert(hosts.size() == flops_amounts.size() || flops_amounts.empty(),
@@ -321,7 +321,8 @@ void parallel_execute(std::vector<s4u::Host*> hosts, std::vector<double> flops_a
 }
 
 // deprecated
-void parallel_execute(int host_nb, s4u::Host** host_list, double* flops_amount, double* bytes_amount, double timeout)
+void parallel_execute(int host_nb, s4u::Host* const* host_list, const double* flops_amount, const double* bytes_amount,
+                      double timeout)
 {
   smx_activity_t s =
       simcall_execution_parallel_start("", host_nb, host_list, flops_amount, bytes_amount, /* rate */ -1, timeout);
@@ -331,7 +332,7 @@ void parallel_execute(int host_nb, s4u::Host** host_list, double* flops_amount,
 }
 
 // deprecated
-void parallel_execute(int host_nb, sg_host_t* host_list, double* flops_amount, double* bytes_amount)
+void parallel_execute(int host_nb, s4u::Host* const* host_list, const double* flops_amount, const double* bytes_amount)
 {
   smx_activity_t s = simcall_execution_parallel_start("", host_nb, host_list, flops_amount, bytes_amount,
                                                       /* rate */ -1, /*timeout*/ -1);

diff --git a/src/simix/libsmx.cpp b/src/simix/libsmx.cpp
index 007f8af..f8d41b2 100644 (file)
--- a/src/simix/libsmx.cpp
+++ b/src/simix/libsmx.cpp
@@ -41,8 +41,9 @@ XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(simix);
  * @param timeout timeout
  * @return A new SIMIX execution synchronization
  */
-smx_activity_t simcall_execution_parallel_start(std::string name, int host_nb, sg_host_t* host_list,
-                                                double* flops_amount, double* bytes_amount, double rate, double timeout)
+smx_activity_t simcall_execution_parallel_start(const std::string& name, int host_nb, const sg_host_t* host_list,
+                                                const double* flops_amount, const double* bytes_amount, double rate,
+                                                double timeout)
 {
   /* checking for infinite values */
   for (int i = 0 ; i < host_nb ; ++i) {

diff --git a/src/simix/smx_host.cpp b/src/simix/smx_host.cpp
index fa667b6..7bd756a 100644 (file)
--- a/src/simix/smx_host.cpp
+++ b/src/simix/smx_host.cpp
@@ -24,9 +24,9 @@ const char* sg_host_self_get_name()
   return host->get_cname();
 }
 
-simgrid::kernel::activity::ExecImplPtr SIMIX_execution_parallel_start(std::string name, int host_nb,
-                                                                      sg_host_t* host_list, double* flops_amount,
-                                                                      double* bytes_amount, double rate, double timeout)
+simgrid::kernel::activity::ExecImplPtr
+SIMIX_execution_parallel_start(std::string name, int host_nb, const sg_host_t* host_list, const double* flops_amount,
+                               const double* bytes_amount, double rate, double timeout)
 {
 
   /* Check that we are not mixing VMs and PMs in the parallel task */

diff --git a/src/simix/smx_host_private.hpp b/src/simix/smx_host_private.hpp
index 094b311..8c13cc2 100644 (file)
--- a/src/simix/smx_host_private.hpp
+++ b/src/simix/smx_host_private.hpp
@@ -13,7 +13,7 @@
 XBT_PRIVATE void SIMIX_execution_finish(smx_activity_t synchro);
 
 XBT_PRIVATE simgrid::kernel::activity::ExecImplPtr
-SIMIX_execution_parallel_start(std::string name, int host_nb, sg_host_t* host_list, double* flops_amount,
-                               double* bytes_amount, double rate, double timeout);
+SIMIX_execution_parallel_start(std::string name, int host_nb, const sg_host_t* host_list, const double* flops_amount,
+                               const double* bytes_amount, double rate, double timeout);
 
 #endif

diff --git a/src/surf/HostImpl.cpp b/src/surf/HostImpl.cpp
index 17788e0..8983db7 100644 (file)
--- a/src/surf/HostImpl.cpp
+++ b/src/surf/HostImpl.cpp
@@ -24,7 +24,7 @@ namespace surf {
  *********/
 
 /* Helper function for executeParallelTask */
-static inline double has_cost(double* array, size_t pos)
+static inline double has_cost(const double* array, size_t pos)
 {
   if (array)
     return array[pos];
@@ -32,8 +32,9 @@ static inline double has_cost(double* array, size_t pos)
     return -1.0;
 }
 
-kernel::resource::Action* HostModel::execute_parallel(size_t host_nb, s4u::Host** host_list, double* flops_amount,
-                                                      double* bytes_amount, double rate)
+kernel::resource::Action* HostModel::execute_parallel(size_t host_nb, s4u::Host* const* host_list,
+                                                      const double* flops_amount, const double* bytes_amount,
+                                                      double rate)
 {
   kernel::resource::Action* action = nullptr;
   if ((host_nb == 1) && (has_cost(bytes_amount, 0) <= 0) && (has_cost(flops_amount, 0) > 0)) {

diff --git a/src/surf/HostImpl.hpp b/src/surf/HostImpl.hpp
index c925dbf..1fa3bc7 100644 (file)
--- a/src/surf/HostImpl.hpp
+++ b/src/surf/HostImpl.hpp
@@ -29,8 +29,9 @@ class XBT_PRIVATE HostModel : public kernel::resource::Model {
 public:
   HostModel() : Model(Model::UpdateAlgo::FULL) {}
 
-  virtual kernel::resource::Action* execute_parallel(size_t host_nb, sg_host_t* host_list, double* flops_amount,
-                                                     double* bytes_amount, double rate);
+  virtual kernel::resource::Action* execute_parallel(size_t host_nb, s4u::Host* const* host_list,
+                                                     const double* flops_amount, const double* bytes_amount,
+                                                     double rate);
 };
 
 /************

diff --git a/src/surf/ptask_L07.cpp b/src/surf/ptask_L07.cpp
index 9668d51..5b6be89 100644 (file)
--- a/src/surf/ptask_L07.cpp
+++ b/src/surf/ptask_L07.cpp
@@ -132,14 +132,15 @@ void HostL07Model::update_actions_state(double /*now*/, double delta)
   }
 }
 
-kernel::resource::Action* HostL07Model::execute_parallel(size_t host_nb, sg_host_t* host_list, double* flops_amount,
-                                                         double* bytes_amount, double rate)
+kernel::resource::Action* HostL07Model::execute_parallel(size_t host_nb, s4u::Host* const* host_list,
+                                                         const double* flops_amount, const double* bytes_amount,
+                                                         double rate)
 {
   return new L07Action(this, host_nb, host_list, flops_amount, bytes_amount, rate);
 }
 
-L07Action::L07Action(kernel::resource::Model* model, size_t host_nb, sg_host_t* host_list, double* flops_amount,
-                     double* bytes_amount, double rate)
+L07Action::L07Action(kernel::resource::Model* model, size_t host_nb, s4u::Host* const* host_list,
+                     const double* flops_amount, const double* bytes_amount, double rate)
     : CpuAction(model, 1, 0), computationAmount_(flops_amount), communicationAmount_(bytes_amount), rate_(rate)
 {
   size_t link_nb      = 0;

diff --git a/src/surf/ptask_L07.hpp b/src/surf/ptask_L07.hpp
index 6f42adf..6cba667 100644 (file)
--- a/src/surf/ptask_L07.hpp
+++ b/src/surf/ptask_L07.hpp
@@ -40,8 +40,8 @@ public:
 
   double next_occuring_event(double now) override;
   void update_actions_state(double now, double delta) override;
-  kernel::resource::Action* execute_parallel(size_t host_nb, sg_host_t* host_list, double* flops_amount,
-                                             double* bytes_amount, double rate) override;
+  kernel::resource::Action* execute_parallel(size_t host_nb, s4u::Host* const* host_list, const double* flops_amount,
+                                             const double* bytes_amount, double rate) override;
 };
 
 class CpuL07Model : public CpuModel {
@@ -104,20 +104,22 @@ public:
 class L07Action : public CpuAction {
   friend Action *CpuL07::execution_start(double size);
   friend Action *CpuL07::sleep(double duration);
-  friend Action* HostL07Model::execute_parallel(size_t host_nb, sg_host_t* host_list, double* flops_amount,
-                                                double* bytes_amount, double rate);
+  friend Action* HostL07Model::execute_parallel(size_t host_nb, s4u::Host* const* host_list, const double* flops_amount,
+                                                const double* bytes_amount, double rate);
   friend Action* NetworkL07Model::communicate(s4u::Host* src, s4u::Host* dst, double size, double rate);
 
 public:
-  L07Action(kernel::resource::Model* model, size_t host_nb, sg_host_t* host_list, double* flops_amount,
-            double* bytes_amount, double rate);
+  L07Action(kernel::resource::Model* model, size_t host_nb, s4u::Host* const* host_list, const double* flops_amount,
+            const double* bytes_amount, double rate);
   ~L07Action();
 
   void updateBound();
 
   std::vector<s4u::Host*> hostList_;
-  double* computationAmount_;   /* pointer to the data that lives in s4u action -- do not free unless if free_arrays */
-  double* communicationAmount_; /* pointer to the data that lives in s4u action -- do not free unless if free_arrays */
+  const double* computationAmount_;   /* pointer to the data that lives in s4u action -- do not free unless if
+                                       * free_arrays */
+  const double* communicationAmount_; /* pointer to the data that lives in s4u action -- do not free unless if
+                                       * free_arrays */
   double latency_;
   double rate_;