X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/55491279cdea3f01da22d1b51874e2e168ac5116..b9625f82f86db0674e911887addce45dca31b57f:/src/s4u/s4u_Exec.cpp

diff --git a/src/s4u/s4u_Exec.cpp b/src/s4u/s4u_Exec.cpp
index 9c75bcad98..7908468702 100644
--- a/src/s4u/s4u_Exec.cpp
+++ b/src/s4u/s4u_Exec.cpp
@@ -3,6 +3,8 @@
 /* This program is free software; you can redistribute it and/or modify it
  * under the terms of the license (GNU LGPL) which comes with this package. */
 
+#include "simgrid/Exception.hpp"
+#include "simgrid/exec.h"
 #include "simgrid/s4u/Actor.hpp"
 #include "simgrid/s4u/Exec.hpp"
 #include "src/kernel/activity/ExecImpl.hpp"
@@ -20,26 +22,6 @@ Exec::Exec()
   pimpl_ = kernel::activity::ExecImplPtr(new kernel::activity::ExecImpl());
 }
 
-bool Exec::test()
-{
-  xbt_assert(state_ == State::INITED || state_ == State::STARTED || state_ == State::STARTING ||
-             state_ == State::FINISHED);
-
-  if (state_ == State::FINISHED)
-    return true;
-
-  if (state_ == State::INITED || state_ == State::STARTING)
-    this->vetoable_start();
-
-  if (simcall_execution_test(pimpl_)) {
-    state_ = State::FINISHED;
-    this->release_dependencies();
-    return true;
-  }
-
-  return false;
-}
-
 Exec* Exec::wait()
 {
   return this->wait_for(-1);
@@ -49,7 +31,9 @@ Exec* Exec::wait_for(double timeout)
 {
   if (state_ == State::INITED)
     vetoable_start();
-  simcall_execution_wait(pimpl_, timeout);
+
+  kernel::actor::ActorImpl* issuer = Actor::self()->get_impl();
+  kernel::actor::simcall_blocking<void>([this, issuer, timeout] { this->get_impl()->wait_for(issuer, timeout); });
   state_ = State::FINISHED;
   on_completion(*Actor::self(), *this);
   this->release_dependencies();
@@ -92,6 +76,30 @@ ExecPtr Exec::set_timeout(double timeout) // XBT_ATTRIB_DEPRECATED_v329
   return this;
 }
 
+ExecPtr Exec::set_flops_amount(double flops_amount)
+{
+  xbt_assert(state_ == State::INITED, "Cannot change the flop_amount of an exec after its start");
+  flops_amounts_.assign(1, flops_amount);
+  Activity::set_remaining(flops_amounts_.front());
+  return this;
+}
+
+ExecPtr Exec::set_flops_amounts(const std::vector<double>& flops_amounts)
+{
+  xbt_assert(state_ == State::INITED, "Cannot change the flops_amounts of an exec after its start");
+  flops_amounts_ = flops_amounts;
+  parallel_      = true;
+  return this;
+}
+
+ExecPtr Exec::set_bytes_amounts(const std::vector<double>& bytes_amounts)
+{
+  xbt_assert(state_ == State::INITED, "Cannot change the bytes_amounts of an exec after its start");
+  bytes_amounts_ = bytes_amounts;
+  parallel_      = true;
+  return this;
+}
+
 /** @brief Retrieve the host on which this activity takes place.
  *  If it runs on more than one host, only the first host is returned.
  */
@@ -129,34 +137,10 @@ ExecPtr Exec::set_priority(double priority)
   return this;
 }
 
-///////////// SEQUENTIAL EXECUTIONS ////////
-ExecSeq::ExecSeq(sg_host_t host, double flops_amount) : Exec(), flops_amount_(flops_amount)
-{
-  Activity::set_remaining(flops_amount_);
-  boost::static_pointer_cast<kernel::activity::ExecImpl>(pimpl_)->set_host(host);
-}
-
-Exec* ExecSeq::start()
-{
-  kernel::actor::simcall([this] {
-    (*boost::static_pointer_cast<kernel::activity::ExecImpl>(pimpl_))
-        .set_name(get_name())
-        .set_tracing_category(get_tracing_category())
-        .set_sharing_penalty(1. / priority_)
-        .set_bound(bound_)
-        .set_flops_amount(flops_amount_)
-        .start();
-  });
-  state_ = State::STARTED;
-  on_start(*Actor::self(), *this);
-  return this;
-}
-
-/** @brief Returns whether the state of the exec is finished */
 /** @brief Change the host on which this activity takes place.
  *
  * The activity cannot be terminated already (but it may be started). */
-ExecPtr ExecSeq::set_host(Host* host)
+ExecPtr Exec::set_host(Host* host)
 {
   xbt_assert(state_ == State::INITED || state_ == State::STARTED,
              "Cannot change the host of an exec once it's done (state: %d)", (int)state_);
@@ -166,54 +150,170 @@ ExecPtr ExecSeq::set_host(Host* host)
   return this;
 }
 
-double ExecSeq::get_remaining()
+ExecPtr Exec::set_hosts(const std::vector<Host*>& hosts)
 {
-  return kernel::actor::simcall(
-      [this]() { return boost::static_pointer_cast<kernel::activity::ExecImpl>(pimpl_)->get_remaining(); });
+  xbt_assert(state_ == State::INITED, "Cannot change the hosts of an exec once it's done (state: %d)", (int)state_);
+  hosts_    = hosts;
+  parallel_ = true;
+  return this;
+}
+
+///////////// SEQUENTIAL EXECUTIONS ////////
+Exec* Exec::start()
+{
+  if (is_parallel())
+    kernel::actor::simcall([this] {
+      (*boost::static_pointer_cast<kernel::activity::ExecImpl>(pimpl_))
+          .set_hosts(hosts_)
+          .set_timeout(timeout_)
+          .set_flops_amounts(flops_amounts_)
+          .set_bytes_amounts(bytes_amounts_)
+          .start();
+    });
+  else
+    kernel::actor::simcall([this] {
+      (*boost::static_pointer_cast<kernel::activity::ExecImpl>(pimpl_))
+          .set_name(get_name())
+          .set_tracing_category(get_tracing_category())
+          .set_sharing_penalty(1. / priority_)
+          .set_bound(bound_)
+          .set_flops_amount(flops_amounts_.front())
+          .start();
+    });
+
+  if (suspended_)
+    pimpl_->suspend();
+
+  state_ = State::STARTED;
+  on_start(*Actor::self(), *this);
+  return this;
+}
+
+double Exec::get_remaining() const
+{
+  if (is_parallel()) {
+    XBT_WARN("Calling get_remaining() on a parallel execution is not allowed. Call get_remaining_ratio() instead.");
+    return get_remaining_ratio();
+  } else
+    return kernel::actor::simcall(
+        [this]() { return boost::static_pointer_cast<kernel::activity::ExecImpl>(pimpl_)->get_remaining(); });
 }
 
 /** @brief Returns the ratio of elements that are still to do
  *
  * The returned value is between 0 (completely done) and 1 (nothing done yet).
  */
-double ExecSeq::get_remaining_ratio()
+double Exec::get_remaining_ratio() const
 {
-  return kernel::actor::simcall(
-      [this]() { return boost::static_pointer_cast<kernel::activity::ExecImpl>(pimpl_)->get_seq_remaining_ratio(); });
+  if (is_parallel())
+    return kernel::actor::simcall(
+        [this]() { return boost::static_pointer_cast<kernel::activity::ExecImpl>(pimpl_)->get_par_remaining_ratio(); });
+  else
+    return kernel::actor::simcall(
+        [this]() { return boost::static_pointer_cast<kernel::activity::ExecImpl>(pimpl_)->get_seq_remaining_ratio(); });
 }
 
-///////////// PARALLEL EXECUTIONS ////////
-ExecPar::ExecPar(const std::vector<s4u::Host*>& hosts, const std::vector<double>& flops_amounts,
-                 const std::vector<double>& bytes_amounts)
-    : Exec(), hosts_(hosts), flops_amounts_(flops_amounts), bytes_amounts_(bytes_amounts)
+} // namespace s4u
+} // namespace simgrid
+/* **************************** Public C interface *************************** */
+void sg_exec_set_bound(sg_exec_t exec, double bound)
 {
+  exec->set_bound(bound);
 }
 
-Exec* ExecPar::start()
+const char* sg_exec_get_name(const_sg_exec_t exec)
 {
-  kernel::actor::simcall([this] {
-    (*boost::static_pointer_cast<kernel::activity::ExecImpl>(pimpl_))
-        .set_hosts(hosts_)
-        .set_timeout(timeout_)
-        .set_flops_amounts(flops_amounts_)
-        .set_bytes_amounts(bytes_amounts_)
-        .start();
-  });
-  state_ = State::STARTED;
-  on_start(*Actor::self(), *this);
-  return this;
+  return exec->get_cname();
 }
 
-double ExecPar::get_remaining_ratio()
+void sg_exec_set_name(sg_exec_t exec, const char* name)
 {
-  return kernel::actor::simcall(
-      [this]() { return boost::static_pointer_cast<kernel::activity::ExecImpl>(pimpl_)->get_par_remaining_ratio(); });
+  exec->set_name(name);
 }
 
-double ExecPar::get_remaining()
+void sg_exec_set_host(sg_exec_t exec, sg_host_t new_host)
 {
-  XBT_WARN("Calling get_remaining() on a parallel execution is not allowed. Call get_remaining_ratio() instead.");
-  return get_remaining_ratio();
+  exec->set_host(new_host);
+}
+
+double sg_exec_get_remaining(const_sg_exec_t exec)
+{
+  return exec->get_remaining();
+}
+
+double sg_exec_get_remaining_ratio(const_sg_exec_t exec)
+{
+  return exec->get_remaining_ratio();
+}
+
+void sg_exec_start(sg_exec_t exec)
+{
+  exec->start();
+}
+
+void sg_exec_cancel(sg_exec_t exec)
+{
+  exec->cancel();
+  exec->unref();
+}
+
+int sg_exec_test(sg_exec_t exec)
+{
+  bool finished = exec->test();
+  if (finished)
+    exec->unref();
+  return finished;
+}
+
+sg_error_t sg_exec_wait(sg_exec_t exec)
+{
+  sg_error_t status = SG_OK;
+
+  simgrid::s4u::ExecPtr s4u_exec(exec, false);
+  try {
+    s4u_exec->wait_for(-1);
+  } catch (const simgrid::TimeoutException&) {
+    status = SG_ERROR_TIMEOUT;
+  } catch (const simgrid::CancelException&) {
+    status = SG_ERROR_CANCELED;
+  } catch (const simgrid::HostFailureException&) {
+    status = SG_ERROR_HOST;
+  }
+  return status;
+}
+
+sg_error_t sg_exec_wait_for(sg_exec_t exec, double timeout)
+{
+  sg_error_t status = SG_OK;
+
+  simgrid::s4u::ExecPtr s4u_exec(exec, false);
+  try {
+    s4u_exec->wait_for(timeout);
+  } catch (const simgrid::TimeoutException&) {
+    status = SG_ERROR_TIMEOUT;
+  } catch (const simgrid::CancelException&) {
+    status = SG_ERROR_CANCELED;
+  } catch (const simgrid::HostFailureException&) {
+    status = SG_ERROR_HOST;
+  }
+  return status;
+}
+
+int sg_exec_wait_any(sg_exec_t* execs, size_t count)
+{
+  return sg_exec_wait_any_for(execs, count, -1);
+}
+
+int 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++)
+    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)
+      s4u_execs[i]->add_ref();
+  }
+  return pos;
 }
-} // namespace s4u
-} // namespace simgrid