Use ssize_t for Exec::wait_any and Io::wait_any too.

diff --git a/examples/c/exec-waitany/exec-waitany.c b/examples/c/exec-waitany/exec-waitany.c
index b5caa0b..e65ade7 100644 (file)
--- a/examples/c/exec-waitany/exec-waitany.c
+++ b/examples/c/exec-waitany/exec-waitany.c
@@ -41,7 +41,7 @@ static void worker(int argc, char* argv[])
    * terminated.
    */
   while (pending_execs_count > 0) {
-    int pos;
+    ssize_t pos;
     if (with_timeout)
       pos = sg_exec_wait_any_for(pending_execs, pending_execs_count, 4);
     else
@@ -51,7 +51,7 @@ static void worker(int argc, char* argv[])
       XBT_INFO("Do not wait any longer for an activity");
       pending_execs_count = 0;
     } else {
-      XBT_INFO("Activity at position %d is complete", pos);
+      XBT_INFO("Activity at position %zd is complete", pos);
       memmove(pending_execs + pos, pending_execs + pos + 1, sizeof(sg_exec_t) * (pending_execs_count - pos - 1));
       pending_execs_count--;
     }

diff --git a/examples/cpp/exec-dependent/s4u-exec-dependent.cpp b/examples/cpp/exec-dependent/s4u-exec-dependent.cpp
index 834921d..0fa1eb9 100644 (file)
--- a/examples/cpp/exec-dependent/s4u-exec-dependent.cpp
+++ b/examples/cpp/exec-dependent/s4u-exec-dependent.cpp
@@ -41,7 +41,7 @@ static void worker()
 
   // wait for the completion of all activities
   while (not pending_execs.empty()) {
-    int changed_pos = simgrid::s4u::Exec::wait_any_for(pending_execs, -1);
+    ssize_t changed_pos = simgrid::s4u::Exec::wait_any_for(pending_execs, -1);
     XBT_INFO("Exec '%s' is complete", pending_execs[changed_pos]->get_cname());
     pending_execs.erase(pending_execs.begin() + changed_pos);
   }

diff --git a/examples/cpp/exec-waitany/s4u-exec-waitany.cpp b/examples/cpp/exec-waitany/s4u-exec-waitany.cpp
index 6b9f365..1149c4c 100644 (file)
--- a/examples/cpp/exec-waitany/s4u-exec-waitany.cpp
+++ b/examples/cpp/exec-waitany/s4u-exec-waitany.cpp
@@ -33,7 +33,7 @@ static void worker(bool with_timeout)
    * terminated.
    */
   while (not pending_executions.empty()) {
-    int pos;
+    ssize_t pos;
     if (with_timeout)
       pos = simgrid::s4u::Exec::wait_any_for(pending_executions, 4);
     else
@@ -43,7 +43,7 @@ static void worker(bool with_timeout)
       XBT_INFO("Do not wait any longer for an activity");
       pending_executions.clear();
     } else {
-      XBT_INFO("Activity '%s' (at position %d) is complete", pending_executions[pos]->get_cname(), pos);
+      XBT_INFO("Activity '%s' (at position %zd) is complete", pending_executions[pos]->get_cname(), pos);
       pending_executions.erase(pending_executions.begin() + pos);
     }
     XBT_INFO("%zu activities remain pending", pending_executions.size());

diff --git a/examples/cpp/io-dependent/s4u-io-dependent.cpp b/examples/cpp/io-dependent/s4u-io-dependent.cpp
index 2174130..3b38e53 100644 (file)
--- a/examples/cpp/io-dependent/s4u-io-dependent.cpp
+++ b/examples/cpp/io-dependent/s4u-io-dependent.cpp
@@ -45,7 +45,7 @@ static void test()
   // wait for the completion of all activities
   bob_compute->wait();
   while (not pending_ios.empty()) {
-    int changed_pos = simgrid::s4u::Io::wait_any(pending_ios);
+    ssize_t changed_pos = simgrid::s4u::Io::wait_any(pending_ios);
     XBT_INFO("Io '%s' is complete", pending_ios[changed_pos]->get_cname());
     pending_ios.erase(pending_ios.begin() + changed_pos);
   }

diff --git a/include/simgrid/exec.h b/include/simgrid/exec.h
index b2402e0..29d2ed5 100644 (file)
--- a/include/simgrid/exec.h
+++ b/include/simgrid/exec.h
@@ -7,6 +7,7 @@
 #define INCLUDE_SIMGRID_EXEC_H_
 
 #include <simgrid/forward.h>
+#include <sys/types.h> /* ssize_t */
 #include <xbt/dynar.h>
 
 /* C interface */
@@ -24,8 +25,8 @@ XBT_PUBLIC void sg_exec_cancel(sg_exec_t exec);
 XBT_PUBLIC int sg_exec_test(sg_exec_t exec);
 XBT_PUBLIC sg_error_t sg_exec_wait(sg_exec_t exec);
 XBT_PUBLIC sg_error_t sg_exec_wait_for(sg_exec_t exec, double timeout);
-XBT_PUBLIC int sg_exec_wait_any_for(sg_exec_t* execs, size_t count, double timeout);
-XBT_PUBLIC int sg_exec_wait_any(sg_exec_t* execs, size_t count);
+XBT_PUBLIC ssize_t sg_exec_wait_any_for(sg_exec_t* execs, size_t count, double timeout);
+XBT_PUBLIC ssize_t sg_exec_wait_any(sg_exec_t* execs, size_t count);
 
 SG_END_DECL
 

diff --git a/include/simgrid/s4u/Exec.hpp b/include/simgrid/s4u/Exec.hpp
index 3fe8ccb..ad8475a 100644 (file)
--- a/include/simgrid/s4u/Exec.hpp
+++ b/include/simgrid/s4u/Exec.hpp
@@ -51,14 +51,14 @@ public:
 
   /*! take a vector of s4u::ExecPtr and return when one of them is finished.
    * The return value is the rank of the first finished ExecPtr. */
-  static int wait_any(const std::vector<ExecPtr>& execs) { return wait_any_for(execs, -1); }
+  static ssize_t wait_any(const std::vector<ExecPtr>& execs) { return wait_any_for(execs, -1); }
   /*! Same as wait_any, but with a timeout. If the timeout occurs, parameter last is returned.*/
-  static int wait_any_for(const std::vector<ExecPtr>& execs, double timeout);
+  static ssize_t wait_any_for(const std::vector<ExecPtr>& execs, double timeout);
 
   XBT_ATTRIB_DEPRECATED_v332("Please use a plain vector for parameter")
-  static int wait_any(std::vector<ExecPtr>* execs) { return wait_any_for(*execs, -1); }
+  static int wait_any(std::vector<ExecPtr>* execs) { return static_cast<int>(wait_any_for(*execs, -1)); }
   XBT_ATTRIB_DEPRECATED_v332("Please use a plain vector for first parameter")
-  static int wait_any_for(std::vector<ExecPtr>* execs, double timeout) { return wait_any_for(*execs, timeout); }
+  static int wait_any_for(std::vector<ExecPtr>* execs, double timeout) { return static_cast<int>(wait_any_for(*execs, timeout)); }
 
   /** @brief On sequential executions, returns the amount of flops that remain to be done; This cannot be used on
    * parallel executions. */

diff --git a/include/simgrid/s4u/Io.hpp b/include/simgrid/s4u/Io.hpp
index dbcff8e..2ed2ca8 100644 (file)
--- a/include/simgrid/s4u/Io.hpp
+++ b/include/simgrid/s4u/Io.hpp
@@ -37,9 +37,9 @@ public:
   Io* start() override;
   /*! take a vector of s4u::IoPtr and return when one of them is finished.
    * The return value is the rank of the first finished IoPtr. */
-  static int wait_any(const std::vector<IoPtr>& ios) { return wait_any_for(ios, -1); }
+  static ssize_t wait_any(const std::vector<IoPtr>& ios) { return wait_any_for(ios, -1); }
   /*! Same as wait_any, but with a timeout. If the timeout occurs, parameter last is returned.*/
-  static int wait_any_for(const std::vector<IoPtr>& ios, double timeout);
+  static ssize_t wait_any_for(const std::vector<IoPtr>& ios, double timeout);
 
   double get_remaining() const override;
   sg_size_t get_performed_ioops() const;

diff --git a/src/kernel/actor/SimcallObserver.hpp b/src/kernel/actor/SimcallObserver.hpp
index ccc4c7b..6f0e143 100644 (file)
--- a/src/kernel/actor/SimcallObserver.hpp
+++ b/src/kernel/actor/SimcallObserver.hpp
@@ -180,7 +180,7 @@ public:
   double get_timeout() const { return timeout_; }
 };
 
-class ExecutionWaitanySimcall : public ResultingSimcall<int> {
+class ExecutionWaitanySimcall : public ResultingSimcall<ssize_t> {
   const std::vector<activity::ExecImpl*>& execs_;
   const double timeout_;
 
@@ -197,7 +197,7 @@ public:
   double get_timeout() const { return timeout_; }
 };
 
-class IoWaitanySimcall : public ResultingSimcall<int> {
+class IoWaitanySimcall : public ResultingSimcall<ssize_t> {
   const std::vector<activity::IoImpl*>& ios_;
   const double timeout_;
 

diff --git a/src/s4u/s4u_Exec.cpp b/src/s4u/s4u_Exec.cpp
index 5cd21a2..71368f7 100644 (file)
--- a/src/s4u/s4u_Exec.cpp
+++ b/src/s4u/s4u_Exec.cpp
@@ -53,7 +53,7 @@ Exec* Exec::start()
   return this;
 }
 
-int Exec::wait_any_for(const std::vector<ExecPtr>& execs, double timeout)
+ssize_t Exec::wait_any_for(const std::vector<ExecPtr>& execs, double timeout)
 {
   std::vector<kernel::activity::ExecImpl*> rexecs(execs.size());
   std::transform(begin(execs), end(execs), begin(rexecs),
@@ -61,7 +61,7 @@ int Exec::wait_any_for(const std::vector<ExecPtr>& execs, double timeout)
 
   kernel::actor::ActorImpl* issuer = kernel::actor::ActorImpl::self();
   kernel::actor::ExecutionWaitanySimcall observer{issuer, rexecs, timeout};
-  int changed_pos = kernel::actor::simcall_blocking(
+  ssize_t changed_pos = kernel::actor::simcall_blocking(
       [&observer] {
         kernel::activity::ExecImpl::wait_any_for(observer.get_issuer(), observer.get_execs(), observer.get_timeout());
       },
@@ -310,20 +310,20 @@ sg_error_t sg_exec_wait_for(sg_exec_t exec, double timeout)
   return status;
 }
 
-int sg_exec_wait_any(sg_exec_t* execs, size_t count)
+ssize_t sg_exec_wait_any(sg_exec_t* execs, size_t count)
 {
   return sg_exec_wait_any_for(execs, count, -1.0);
 }
 
-int sg_exec_wait_any_for(sg_exec_t* execs, size_t count, double timeout)
+ssize_t sg_exec_wait_any_for(sg_exec_t* execs, size_t count, double timeout)
 {
   std::vector<simgrid::s4u::ExecPtr> s4u_execs;
-  for (unsigned int i = 0; i < count; i++)
+  for (size_t i = 0; i < count; i++)
     s4u_execs.emplace_back(execs[i], false);
 
-  int pos = simgrid::s4u::Exec::wait_any_for(s4u_execs, timeout);
-  for (unsigned i = 0; i < count; i++) {
-    if (pos != -1 && static_cast<unsigned>(pos) != i)
+  ssize_t pos = simgrid::s4u::Exec::wait_any_for(s4u_execs, timeout);
+  for (size_t i = 0; i < count; i++) {
+    if (pos != -1 && static_cast<size_t>(pos) != i)
       s4u_execs[i]->add_ref();
   }
   return pos;

diff --git a/src/s4u/s4u_Io.cpp b/src/s4u/s4u_Io.cpp
index a4aba5b..38050e1 100644 (file)
--- a/src/s4u/s4u_Io.cpp
+++ b/src/s4u/s4u_Io.cpp
@@ -46,7 +46,7 @@ Io* Io::start()
   return this;
 }
 
-int Io::wait_any_for(const std::vector<IoPtr>& ios, double timeout)
+ssize_t Io::wait_any_for(const std::vector<IoPtr>& ios, double timeout)
 {
   std::vector<kernel::activity::IoImpl*> rios(ios.size());
   std::transform(begin(ios), end(ios), begin(rios),
@@ -54,7 +54,7 @@ int Io::wait_any_for(const std::vector<IoPtr>& ios, double timeout)
 
   kernel::actor::ActorImpl* issuer = kernel::actor::ActorImpl::self();
   kernel::actor::IoWaitanySimcall observer{issuer, rios, timeout};
-  int changed_pos = kernel::actor::simcall_blocking(
+  ssize_t changed_pos = kernel::actor::simcall_blocking(
       [&observer] {
         kernel::activity::IoImpl::wait_any_for(observer.get_issuer(), observer.get_ios(), observer.get_timeout());
       },

diff --git a/teshsuite/s4u/activity-lifecycle/testing_test-wait.cpp b/teshsuite/s4u/activity-lifecycle/testing_test-wait.cpp
index e47abd6..006b6f5 100644 (file)
--- a/teshsuite/s4u/activity-lifecycle/testing_test-wait.cpp
+++ b/teshsuite/s4u/activity-lifecycle/testing_test-wait.cpp
@@ -62,14 +62,14 @@ template <int Duration, typename Activity> bool tester_wait_any(const Activity&
   try {
     std::vector<Activity> activities = {activity};
     XBT_DEBUG("calling wait_any_for(%f)", duration);
-    int index = Activity::element_type::wait_any_for(activities, duration);
+    ssize_t index = Activity::element_type::wait_any_for(activities, duration);
     if (index == -1) {
       XBT_DEBUG("wait_any_for() timed out");
       INFO("wait_any_for() timeout should expire at expected date: " << timeout);
       REQUIRE(simgrid::s4u::Engine::get_clock() == Approx(timeout));
       ret = false;
     } else {
-      XBT_DEBUG("wait_any_for() returned index %d", index);
+      XBT_DEBUG("wait_any_for() returned index %zd", index);
       REQUIRE(index == 0);
       ret = true;
     }