Deprecate the C API of parallel_execute

[simgrid.git] / include / simgrid / s4u / Actor.hpp

diff --git a/include/simgrid/s4u/Actor.hpp b/include/simgrid/s4u/Actor.hpp
index 54f83a7..926cefb 100644 (file)
--- a/include/simgrid/s4u/Actor.hpp
+++ b/include/simgrid/s4u/Actor.hpp
@@ -98,8 +98,8 @@ namespace s4u {
  *
  * @code{.xml}
  * <?xml version='1.0'?>
- * <!DOCTYPE platform SYSTEM "http://simgrid.gforge.inria.fr/simgrid/simgrid.dtd">
- * <platform version="4">
+ * <!DOCTYPE platform SYSTEM "https://simgrid.org/simgrid.dtd">
+ * <platform version="4.1">
  *
  *   <!-- Start an actor called 'master' on the host called 'Tremblay' -->
  *   <actor host="Tremblay" function="master">
@@ -410,6 +410,10 @@ XBT_PUBLIC void execute(double flop);
  *  An execution of priority 2 computes twice as fast as an execution at priority 1. */
 XBT_PUBLIC void execute(double flop, double priority);
 
+/**
+ * @example examples/s4u/exec-ptask/s4u-exec-ptask.cpp
+ */
+
 /** Block the actor until the built parallel execution terminates
  *
  * \rst
@@ -429,6 +433,9 @@ XBT_PUBLIC void execute(double flop, double priority);
  * each host, using a vector of flops amount. Then, you should specify the amount of data exchanged between each
  * hosts during the parallel kernel. For that, a matrix of values is expected.
  *
+ * It is OK to build a parallel execution without any computation and/or without any communication.
+ * Just pass an empty vector to the corresponding parameter.
+ *
  * For example, if your list of hosts is ``[host0, host1]``, passing a vector ``[1000, 2000]`` as a `flops_amount`
  * vector means that `host0` should compute 1000 flops while `host1` will compute 2000 flops. A matrix of
  * communications' sizes of ``[0, 1, 2, 3]`` specifies the following data exchanges:
@@ -451,20 +458,29 @@ XBT_PUBLIC void execute(double flop, double priority);
  * because of contention, this slows down the parallel execution as a whole.
  *
  * These objects are somewhat surprising from a modeling point of view. For example, the unit of their speed is
- * somewhere between flop/sec and byte/sec. It is **strongly advised** to only use the LV08 host model when using
- * parallel executions. Note that you can mix regular executions and communications with parallel executions,
- * provided that the platform model is LV08.
- *
+ * somewhere between flop/sec and byte/sec. Arbitrary parallel executions will simply not work with the usual platform
+ * models, and you must :ref:`use the ptask_L07 host model <options_model_select>` for that. Note that you can mix
+ * regular executions and communications with parallel executions, provided that the host model is ptask_L07.
  *
  * \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(int host_nb, s4u::Host* host_list, double* flops_amount, double* bytes_amount);
 /** \rst
  * Block the actor until the built :ref:`parallel execution <API_s4u_parallel_execute>` completes, or until the timeout.
- * \endrst*/
-XBT_PUBLIC void parallel_execute(int host_nb, s4u::Host* host_list, double* flops_amount, double* bytes_amount,
-                                 double timeout);
+ * \endrst
+ */
+XBT_PUBLIC void parallel_execute(std::vector<s4u::Host*> hosts, std::vector<double> flops_amounts,
+                                 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);
+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);
+#endif
 
 XBT_PUBLIC ExecPtr exec_init(double flops_amounts);
 XBT_PUBLIC ExecPtr exec_async(double flops_amounts);