* 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
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--;
}
// 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);
}
* 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
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());
// 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);
}
#define INCLUDE_SIMGRID_EXEC_H_
#include <simgrid/forward.h>
+#include <sys/types.h> /* ssize_t */
#include <xbt/dynar.h>
/* C interface */
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
/*! 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. */
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;
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_;
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_;
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),
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());
},
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;
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),
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());
},
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;
}