cosmetics

[simgrid.git] / src / s4u / s4u_Actor.cpp

diff --git a/src/s4u/s4u_Actor.cpp b/src/s4u/s4u_Actor.cpp
index 0ab25b8..5937ec7 100644 (file)
--- a/src/s4u/s4u_Actor.cpp
+++ b/src/s4u/s4u_Actor.cpp
@@ -41,7 +41,7 @@ xbt::signal<void(Actor const&)> s4u::Actor::on_destruction;
 // ***** Actor creation *****
 Actor* Actor::self()
 {
-  kernel::context::Context* self_context = kernel::context::Context::self();
+  const kernel::context::Context* self_context = kernel::context::Context::self();
   if (self_context == nullptr)
     return nullptr;
 
@@ -56,6 +56,15 @@ ActorPtr Actor::init(const std::string& name, s4u::Host* host)
   return actor->iface();
 }
 
+/** Set a non-default stack size for this context (in Kb)
+ *
+ * This must be done before starting the actor, and it won't work with the thread factory. */
+ActorPtr Actor::set_stacksize(unsigned stacksize)
+{
+  pimpl_->set_stacksize(stacksize * 1024);
+  return this;
+}
+
 ActorPtr Actor::start(const std::function<void()>& code)
 {
   simgrid::kernel::actor::simcall([this, &code] { pimpl_->start(code); });
@@ -361,7 +370,9 @@ void parallel_execute(const std::vector<s4u::Host*>& hosts, const std::vector<do
 
 ExecPtr exec_init(double flops_amount)
 {
-  return ExecPtr(new ExecSeq(get_host(), flops_amount));
+  ExecPtr exec = ExecPtr(new Exec());
+  exec->set_flops_amount(flops_amount)->set_host(get_host());
+  return exec;
 }
 
 ExecPtr exec_init(const std::vector<s4u::Host*>& hosts, const std::vector<double>& flops_amounts,
@@ -387,7 +398,9 @@ ExecPtr exec_init(const std::vector<s4u::Host*>& hosts, const std::vector<double
   xbt_assert(std::all_of(bytes_amounts.begin(), bytes_amounts.end(), [](double elm) { return std::isfinite(elm); }),
              "flops_amounts comprises infinite values!");
 
-  return ExecPtr(new ExecPar(hosts, flops_amounts, bytes_amounts));
+  ExecPtr exec = ExecPtr(new Exec());
+  exec->set_flops_amounts(flops_amounts)->set_bytes_amounts(bytes_amounts)->set_hosts(hosts);
+  return exec;
 }
 
 ExecPtr exec_async(double flops)
@@ -472,6 +485,17 @@ void sg_actor_start(sg_actor_t actor, xbt_main_func_t code, int argc, const char
   actor->start(std::move(function));
 }
 
+sg_actor_t sg_actor_create(const char* name, sg_host_t host, xbt_main_func_t code, int argc, const char* const* argv)
+{
+  simgrid::kernel::actor::ActorCode function = simgrid::xbt::wrap_main(code, argc, argv);
+  return simgrid::s4u::Actor::init(name, host)->start(std::move(function)).get();
+}
+
+void sg_actor_set_stacksize(sg_actor_t actor, unsigned size)
+{
+  actor->set_stacksize(size);
+}
+
 void sg_actor_exit()
 {
   simgrid::s4u::this_actor::exit();
@@ -610,7 +634,7 @@ void sg_actor_daemonize(sg_actor_t actor)
 }
 
 /** Returns whether or not this actor has been daemonized or not */
-int sg_actor_is_daemon(sg_actor_t actor)
+int sg_actor_is_daemon(const_sg_actor_t actor)
 {
   return actor->is_daemon();
 }
@@ -735,11 +759,33 @@ sg_actor_t sg_actor_self()
   return simgrid::s4u::Actor::self();
 }
 
-void sg_actor_self_execute(double flops)
+void sg_actor_self_execute(double flops) // XBT_DEPRECATED_v330
 {
   simgrid::s4u::this_actor::execute(flops);
 }
 
+void sg_actor_execute(double flops)
+{
+  simgrid::s4u::this_actor::execute(flops);
+}
+void sg_actor_execute_with_priority(double flops, double priority)
+{
+  simgrid::s4u::this_actor::exec_init(flops)->set_priority(priority)->wait();
+}
+
+void sg_actor_parallel_execute(int host_nb, sg_host_t* host_list, double* flops_amount, double* bytes_amount)
+{
+  std::vector<simgrid::s4u::Host*> hosts(host_list, host_list + host_nb);
+  std::vector<double> flops;
+  std::vector<double> bytes;
+  if (flops_amount != nullptr)
+    flops = std::vector<double>(flops_amount, flops_amount + host_nb);
+  if (bytes_amount != nullptr)
+    bytes = std::vector<double>(bytes_amount, bytes_amount + host_nb * host_nb);
+
+  simgrid::s4u::this_actor::parallel_execute(hosts, flops, bytes);
+}
+
 /** @brief Take an extra reference on that actor to prevent it to be garbage-collected */
 void sg_actor_ref(const_sg_actor_t actor)
 {
@@ -769,3 +815,34 @@ void sg_actor_on_exit(int_f_int_pvoid_t fun, void* data)
 {
   simgrid::s4u::this_actor::on_exit([fun, data](bool failed) { fun(failed ? 1 /*FAILURE*/ : 0 /*SUCCESS*/, data); });
 }
+
+sg_exec_t sg_actor_exec_init(double computation_amount)
+{
+  simgrid::s4u::ExecPtr exec = simgrid::s4u::this_actor::exec_init(computation_amount);
+  exec->add_ref();
+  return exec.get();
+}
+
+sg_exec_t sg_actor_parallel_exec_init(int host_nb, const sg_host_t* host_list, double* flops_amount,
+                                      double* bytes_amount)
+{
+  std::vector<simgrid::s4u::Host*> hosts(host_list, host_list + host_nb);
+  std::vector<double> flops;
+  std::vector<double> bytes;
+  if (flops_amount != nullptr)
+    flops = std::vector<double>(flops_amount, flops_amount + host_nb);
+  if (bytes_amount != nullptr)
+    bytes = std::vector<double>(bytes_amount, bytes_amount + host_nb * host_nb);
+
+  simgrid::s4u::ExecPtr exec = simgrid::s4u::ExecPtr(new simgrid::s4u::Exec());
+  exec->set_flops_amounts(flops)->set_bytes_amounts(bytes)->set_hosts(hosts);
+  exec->add_ref();
+  return exec.get();
+}
+
+sg_exec_t sg_actor_exec_async(double computation_amount)
+{
+  simgrid::s4u::ExecPtr exec = simgrid::s4u::this_actor::exec_async(computation_amount);
+  exec->add_ref();
+  return exec.get();
+}