X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/54760fdf933a7a8b677994fef3254f5fc943e05f..d8242f44e244b1200a521bb2eb97397fa7e84471:/src/bindings/python/simgrid_python.cpp

diff --git a/src/bindings/python/simgrid_python.cpp b/src/bindings/python/simgrid_python.cpp
index a392042e7d..deaa3af282 100644
--- a/src/bindings/python/simgrid_python.cpp
+++ b/src/bindings/python/simgrid_python.cpp
@@ -108,50 +108,47 @@ PYBIND11_MODULE(simgrid, m)
 
   /* this_actor namespace */
   m.def_submodule("this_actor", "Bindings of the s4u::this_actor namespace.")
-      .def("info", [](const char* s) { XBT_INFO("%s", s); }, "Display a logging message of 'info' priority.")
-      .def("error", [](const char* s) { XBT_ERROR("%s", s); }, "Display a logging message of 'error' priority.")
+      .def(
+          "info", [](const char* s) { XBT_INFO("%s", s); }, "Display a logging message of 'info' priority.")
+      .def(
+          "error", [](const char* s) { XBT_ERROR("%s", s); }, "Display a logging message of 'error' priority.")
       .def("execute", py::overload_cast<double, double>(&simgrid::s4u::this_actor::execute),
            py::call_guard<GilScopedRelease>(),
-           "Block the current actor, computing the given amount of flops at the given priority, "
-           "see :cpp:func:`void simgrid::s4u::this_actor::execute(double, double)`",
-           py::arg("flops"), py::arg("priority") = 1)
+           "Block the current actor, computing the given amount of flops at the given priority.", py::arg("flops"),
+           py::arg("priority") = 1)
       .def("exec_init", py::overload_cast<double>(&simgrid::s4u::this_actor::exec_init),
            py::call_guard<GilScopedRelease>())
       .def("get_host", &simgrid::s4u::this_actor::get_host, "Retrieves host on which the current actor is located")
       .def("set_host", &simgrid::s4u::this_actor::set_host, py::call_guard<GilScopedRelease>(),
-           "Moves the current actor to another host, see :cpp:func:`void simgrid::s4u::this_actor::set_host()`",
-           py::arg("dest"))
+           "Moves the current actor to another host.", py::arg("dest"))
       .def("sleep_for", static_cast<void (*)(double)>(&simgrid::s4u::this_actor::sleep_for),
-           py::call_guard<GilScopedRelease>(), "Block the actor sleeping for that amount of seconds, "
-                                               "see :cpp:func:`void simgrid::s4u::this_actor::sleep_for`",
+           py::call_guard<GilScopedRelease>(), "Block the actor sleeping for that amount of seconds.",
            py::arg("duration"))
       .def("sleep_until", static_cast<void (*)(double)>(&simgrid::s4u::this_actor::sleep_until),
-           py::call_guard<GilScopedRelease>(), "Block the actor sleeping until the specified timestamp, "
-                                               "see :cpp:func:`void simgrid::s4u::this_actor::sleep_until`",
+           py::call_guard<GilScopedRelease>(), "Block the actor sleeping until the specified timestamp.",
            py::arg("duration"))
       .def("suspend", &simgrid::s4u::this_actor::suspend, py::call_guard<GilScopedRelease>(),
-           "Suspend the current actor, that is blocked until resume()ed by another actor. "
-           "see :cpp:func:`void simgrid::s4u::this_actor::suspend`")
-      .def("yield_", &simgrid::s4u::this_actor::yield, py::call_guard<GilScopedRelease>(),
-           "Yield the actor, see :cpp:func:`void simgrid::s4u::this_actor::yield()`")
+           "Suspend the current actor, that is blocked until resume()ed by another actor.")
+      .def("yield_", &simgrid::s4u::this_actor::yield, py::call_guard<GilScopedRelease>(), "Yield the actor")
       .def("exit", &simgrid::s4u::this_actor::exit, py::call_guard<GilScopedRelease>(), "kill the current actor")
-      .def("on_exit",
-           [](py::object fun) {
-             simgrid::s4u::this_actor::on_exit([fun](bool /*failed*/) {
-               GilScopedAcquire py_context; // need a new context for callback
-               try {
-                 fun();
-               } catch (const py::error_already_set& e) {
-                 std::string what = e.what();
-                 py_context.reset();
-                 xbt_die("Error while executing the on_exit lambda: %s", what.c_str());
-               }
-             });
-           },
-           py::call_guard<GilScopedRelease>(), "");
+      .def(
+          "on_exit",
+          [](py::object fun) {
+            simgrid::s4u::this_actor::on_exit([fun](bool /*failed*/) {
+              GilScopedAcquire py_context; // need a new context for callback
+              try {
+                fun();
+              } catch (const py::error_already_set& e) {
+                std::string what = e.what();
+                py_context.reset();
+                xbt_die("Error while executing the on_exit lambda: %s", what.c_str());
+              }
+            });
+          },
+          py::call_guard<GilScopedRelease>(), "");
 
   /* Class Engine */
-  py::class_<Engine>(m, "Engine", "Simulation Engine, see :ref:`class s4u::Engine <API_s4u_Engine>`")
+  py::class_<Engine>(m, "Engine", "Simulation Engine")
       .def(py::init([](std::vector<std::string> args) {
         static char noarg[] = {'\0'};
         int argc            = args.size();
@@ -165,187 +162,180 @@ PYBIND11_MODULE(simgrid, m)
       .def_static("get_clock", &Engine::get_clock,
                   "The simulation time, ie the amount of simulated seconds since the simulation start.")
       .def("get_all_hosts", &Engine::get_all_hosts, "Returns the list of all hosts found in the platform")
-      .def("load_platform", &Engine::load_platform,
-           "Load a platform file describing the environment, see :cpp:func:`simgrid::s4u::Engine::load_platform()`")
-      .def("load_deployment", &Engine::load_deployment,
-           "Load a deployment file and launch the actors that it contains, see "
-           ":cpp:func:`simgrid::s4u::Engine::load_deployment()`")
+      .def("load_platform", &Engine::load_platform, "Load a platform file describing the environment")
+      .def("load_deployment", &Engine::load_deployment, "Load a deployment file and launch the actors that it contains")
       .def("run", &Engine::run, py::call_guard<GilScopedRelease>(), "Run the simulation")
-      .def("register_actor",
-           [](Engine* e, const std::string& name, py::object fun_or_class) {
-             e->register_actor(name, [fun_or_class](std::vector<std::string> args) {
-               GilScopedAcquire py_context;
-               try {
-                 /* Convert the std::vector into a py::tuple */
-                 py::tuple params(args.size() - 1);
-                 for (size_t i = 1; i < args.size(); i++)
-                   params[i - 1] = py::cast(args[i]);
+      .def(
+          "register_actor",
+          [](Engine* e, const std::string& name, py::object fun_or_class) {
+            e->register_actor(name, [fun_or_class](std::vector<std::string> args) {
+              GilScopedAcquire py_context;
+              try {
+                /* Convert the std::vector into a py::tuple */
+                py::tuple params(args.size() - 1);
+                for (size_t i = 1; i < args.size(); i++)
+                  params[i - 1] = py::cast(args[i]);
 
-                 py::object res = fun_or_class(*params);
+                py::object res = fun_or_class(*params);
 
-                 /* If I was passed a class, I just built an instance, so I need to call it now */
-                 if (py::isinstance<py::function>(res))
-                   res();
-               } catch (const py::error_already_set& ex) {
-                 bool ffk = ex.matches(pyForcefulKillEx);
-                 py_context.reset();
-                 if (ffk) {
-                   XBT_VERB("Actor killed");
-                   /* Forward that ForcefulKill exception */
-                   simgrid::ForcefulKillException::do_throw();
-                 }
-                 throw;
-               }
-             });
-           },
-           "Registers the main function of an actor, see :cpp:func:`simgrid::s4u::Engine::register_actor()`");
+                /* If I was passed a class, I just built an instance, so I need to call it now */
+                if (py::isinstance<py::function>(res))
+                  res();
+              } catch (const py::error_already_set& ex) {
+                bool ffk = ex.matches(pyForcefulKillEx);
+                py_context.reset();
+                if (ffk) {
+                  XBT_VERB("Actor killed");
+                  /* Forward that ForcefulKill exception */
+                  simgrid::ForcefulKillException::do_throw();
+                }
+                throw;
+              }
+            });
+          },
+          "Registers the main function of an actor");
 
   /* Class Host */
-  py::class_<simgrid::s4u::Host, std::unique_ptr<Host, py::nodelete>>(
-      m, "Host", "Simulation Engine, see :ref:`class s4u::Host <API_s4u_Host>`")
+  py::class_<simgrid::s4u::Host, std::unique_ptr<Host, py::nodelete>>(m, "Host", "Simulated host")
       .def("by_name", &Host::by_name, "Retrieves a host from its name, or die")
-      .def("get_pstate_count", &Host::get_pstate_count,
-           "Retrieve the cound of defined pstate levels, see :cpp:func:`simgrid::s4u::Host::get_pstate_count`")
-      .def("get_pstate_speed", &Host::get_pstate_speed,
-           "Retrieve the maximal speed at the given pstate, see :cpp:func:`simgrid::s4u::Host::get_pstate_speed`")
-      .def_property("pstate", &Host::get_pstate,
-                    [](Host* h, int i) {
-                      GilScopedRelease gil_guard;
-                      h->set_pstate(i);
-                    },
-                    "The current pstate")
+      .def("get_pstate_count", &Host::get_pstate_count, "Retrieve the cound of defined pstate levels")
+      .def("get_pstate_speed", &Host::get_pstate_speed, "Retrieve the maximal speed at the given pstate")
+      .def_property(
+          "pstate", &Host::get_pstate,
+          [](Host* h, int i) {
+            GilScopedRelease gil_guard;
+            h->set_pstate(i);
+          },
+          "The current pstate")
       .def("current", &Host::current, py::call_guard<GilScopedRelease>(),
-           "Retrieves the host on which the running actor is located, see :cpp:func:`simgrid::s4u::Host::current()`")
-      .def_property_readonly("name",
-                             [](const Host* self) {
-                               return std::string(self->get_name().c_str()); // Convert from xbt::string because of MC
-                             },
-                             "The name of this host")
+           "Retrieves the host on which the running actor is located.")
+      .def_property_readonly(
+          "name",
+          [](const Host* self) {
+            return std::string(self->get_name().c_str()); // Convert from xbt::string because of MC
+          },
+          "The name of this host")
       .def_property_readonly(
           "load", &Host::get_load,
-          "Returns the current computation load (in flops per second). This is the currently achieved speed. "
-          "See :cpp:func:`simgrid::s4u::Host::get_load()`")
+          "Returns the current computation load (in flops per second). This is the currently achieved speed.")
       .def_property_readonly(
           "speed", &Host::get_speed,
           "The peak computing speed in flops/s at the current pstate, taking the external load into account. "
-          "This is the max potential speed. See :cpp:func:`simgrid::s4u::Host::get_speed()`");
+          "This is the max potential speed.");
 
   /* Class Mailbox */
-  py::class_<simgrid::s4u::Mailbox, std::unique_ptr<Mailbox, py::nodelete>>(
-      m, "Mailbox", "Mailbox, see :ref:`class s4u::Mailbox <API_s4u_Mailbox>`")
-      .def("__str__", [](const Mailbox* self) { return std::string("Mailbox(") + self->get_cname() + ")"; },
-           "Textual representation of the Mailbox`")
-      .def("by_name", &Mailbox::by_name, py::call_guard<GilScopedRelease>(),
-           "Retrieve a Mailbox from its name, see :cpp:func:`simgrid::s4u::Mailbox::by_name()`")
-      .def_property_readonly("name",
-                             [](const Mailbox* self) {
-                               return std::string(self->get_name().c_str()); // Convert from xbt::string because of MC
-                             },
-                             "The name of that mailbox, see :cpp:func:`simgrid::s4u::Mailbox::get_name()`")
-      .def("put",
-           [](Mailbox* self, py::object data, int size) {
-             data.inc_ref();
-             self->put(data.ptr(), size);
-           },
-           py::call_guard<GilScopedRelease>(),
-           "Blocking data transmission, see :cpp:func:`void simgrid::s4u::Mailbox::put(void*, uint64_t)`")
-      .def("put_async",
-           [](Mailbox* self, py::object data, int size) {
-             data.inc_ref();
-             return self->put_async(data.ptr(), size);
-           },
-           py::call_guard<GilScopedRelease>(),
-           "Non-blocking data transmission, see :cpp:func:`void simgrid::s4u::Mailbox::put_async(void*, uint64_t)`")
-      .def("get",
-           [](Mailbox* self) {
-             py::object data = pybind11::reinterpret_steal<py::object>(static_cast<PyObject*>(self->get()));
-             // data.dec_ref(); // FIXME: why does it break python-actor-create?
-             return data;
-           },
-           py::call_guard<GilScopedRelease>(),
-           "Blocking data reception, see :cpp:func:`void* simgrid::s4u::Mailbox::get()`");
+  py::class_<simgrid::s4u::Mailbox, std::unique_ptr<Mailbox, py::nodelete>>(m, "Mailbox", "Mailbox")
+      .def(
+          "__str__", [](const Mailbox* self) { return std::string("Mailbox(") + self->get_cname() + ")"; },
+          "Textual representation of the Mailbox`")
+      .def("by_name", &Mailbox::by_name, py::call_guard<GilScopedRelease>(), "Retrieve a Mailbox from its name")
+      .def_property_readonly(
+          "name",
+          [](const Mailbox* self) {
+            return std::string(self->get_name().c_str()); // Convert from xbt::string because of MC
+          },
+          "The name of that mailbox")
+      .def(
+          "put",
+          [](Mailbox* self, py::object data, int size) {
+            data.inc_ref();
+            self->put(data.ptr(), size);
+          },
+          py::call_guard<GilScopedRelease>(), "Blocking data transmission")
+      .def(
+          "put_async",
+          [](Mailbox* self, py::object data, int size) {
+            data.inc_ref();
+            return self->put_async(data.ptr(), size);
+          },
+          py::call_guard<GilScopedRelease>(), "Non-blocking data transmission")
+      .def(
+          "get",
+          [](Mailbox* self) {
+            py::object data = pybind11::reinterpret_steal<py::object>(static_cast<PyObject*>(self->get()));
+            // data.dec_ref(); // FIXME: why does it break python-actor-create?
+            return data;
+          },
+          py::call_guard<GilScopedRelease>(), "Blocking data reception");
 
   /* Class Comm */
-  py::class_<simgrid::s4u::Comm, simgrid::s4u::CommPtr>(m, "Comm",
-                                                        "Communication, see :ref:`class s4u::Comm <API_s4u_Comm>`")
+  py::class_<simgrid::s4u::Comm, simgrid::s4u::CommPtr>(m, "Comm", "Communication")
       .def("test", &simgrid::s4u::Comm::test, py::call_guard<GilScopedRelease>(),
-           "Test whether the communication is terminated, see :cpp:func:`simgrid::s4u::Comm::test()`")
+           "Test whether the communication is terminated.")
       .def("wait", &simgrid::s4u::Comm::wait, py::call_guard<GilScopedRelease>(),
-           "Block until the completion of that communication, see :cpp:func:`simgrid::s4u::Comm::wait()`")
+           "Block until the completion of that communication.")
       .def("wait_all", &simgrid::s4u::Comm::wait_all, py::call_guard<GilScopedRelease>(),
-           "Block until the completion of all communications in the list, see "
-           ":cpp:func:`simgrid::s4u::Comm::wait_all()`")
+           "Block until the completion of all communications in the list.")
       .def("wait_any", &simgrid::s4u::Comm::wait_any, py::call_guard<GilScopedRelease>(),
-           "Block until the completion of any communication in the list and return the index of the terminated one, "
-           "see :cpp:func:`simgrid::s4u::Comm::wait_any()`");
+           "Block until the completion of any communication in the list and return the index of the terminated one.");
 
   /* Class Exec */
-  py::class_<simgrid::s4u::Exec, simgrid::s4u::ExecPtr>(m, "Exec",
-                                                        "Execution, see :ref:`class s4u::Exec <API_s4u_Exec>`")
-      .def_property_readonly("remaining",
-                             [](simgrid::s4u::ExecPtr self) {
-                               GilScopedRelease gil_guard;
-                               return self->get_remaining();
-                             },
-                             "Amount of flops that remain to be computed until completion, see "
-                             ":cpp:func:`simgrid::s4u::Exec::get_remaining()`")
-      .def_property_readonly("remaining_ratio",
-                             [](simgrid::s4u::ExecPtr self) {
-                               GilScopedRelease gil_guard;
-                               return self->get_remaining_ratio();
-                             },
-                             "Amount of work remaining until completion from 0 (completely done) to 1 (nothing done "
-                             "yet). See :cpp:func:`simgrid::s4u::Exec::get_remaining_ratio()`")
-      .def_property("host",
-                    [](simgrid::s4u::ExecPtr self) {
-                      simgrid::s4u::ExecSeqPtr seq = boost::dynamic_pointer_cast<simgrid::s4u::ExecSeq>(self);
-                      if (seq != nullptr)
-                        return seq->get_host();
-                      xbt_throw_unimplemented(__FILE__, __LINE__,
-                                              "host of parallel executions is not implemented in python yet.");
-                    },
-                    &simgrid::s4u::Exec::set_host,
-                    "Host on which this execution runs. See :cpp:func:`simgrid::s4u::ExecSeq::get_host()`")
+  py::class_<simgrid::s4u::Exec, simgrid::s4u::ExecPtr>(m, "Exec", "Execution")
+      .def_property_readonly(
+          "remaining",
+          [](simgrid::s4u::ExecPtr self) {
+            GilScopedRelease gil_guard;
+            return self->get_remaining();
+          },
+          "Amount of flops that remain to be computed until completion.")
+      .def_property_readonly(
+          "remaining_ratio",
+          [](simgrid::s4u::ExecPtr self) {
+            GilScopedRelease gil_guard;
+            return self->get_remaining_ratio();
+          },
+          "Amount of work remaining until completion from 0 (completely done) to 1 (nothing done "
+          "yet).")
+      .def_property(
+          "host",
+          [](simgrid::s4u::ExecPtr self) {
+            simgrid::s4u::ExecSeqPtr seq = boost::dynamic_pointer_cast<simgrid::s4u::ExecSeq>(self);
+            if (seq != nullptr)
+              return seq->get_host();
+            xbt_throw_unimplemented(__FILE__, __LINE__,
+                                    "host of parallel executions is not implemented in python yet.");
+          },
+          &simgrid::s4u::Exec::set_host, "Host on which this execution runs.")
       .def("test", &simgrid::s4u::Exec::test, py::call_guard<GilScopedRelease>(),
-           "Test whether the execution is terminated, see :cpp:func:`simgrid::s4u::Exec::test()`")
-      .def("cancel", &simgrid::s4u::Exec::cancel, py::call_guard<GilScopedRelease>(),
-           "Cancel that execution, see :cpp:func:`simgrid::s4u::Exec::cancel()`")
-      .def("start", &simgrid::s4u::Exec::start, py::call_guard<GilScopedRelease>(),
-           "Start that execution, see :cpp:func:`simgrid::s4u::Exec::start()`")
+           "Test whether the execution is terminated.")
+      .def("cancel", &simgrid::s4u::Exec::cancel, py::call_guard<GilScopedRelease>(), "Cancel that execution.")
+      .def("start", &simgrid::s4u::Exec::start, py::call_guard<GilScopedRelease>(), "Start that execution.")
       .def("wait", &simgrid::s4u::Exec::wait, py::call_guard<GilScopedRelease>(),
-           "Block until the completion of that execution, see :cpp:func:`simgrid::s4u::Exec::wait()`");
+           "Block until the completion of that execution.");
 
   /* Class Actor */
   py::class_<simgrid::s4u::Actor, ActorPtr>(m, "Actor",
                                             "An actor is an independent stream of execution in your distributed "
-                                            "application, see :ref:`class s4u::Actor <API_s4u_Actor>`")
-      .def("create",
-           [](py::str name, Host* host, py::object fun, py::args args) {
-             fun.inc_ref();  // FIXME: why is this needed for tests like exec-async, exec-dvfs and exec-remote?
-             args.inc_ref(); // FIXME: why is this needed for tests like actor-migrate?
-             return simgrid::s4u::Actor::create(name, host, [fun, args]() {
-               GilScopedAcquire py_context;
-               try {
-                 fun(*args);
-               } catch (const py::error_already_set& ex) {
-                 bool ffk = ex.matches(pyForcefulKillEx);
-                 py_context.reset();
-                 if (ffk) {
-                   XBT_VERB("Actor killed");
-                   /* Forward that ForcefulKill exception */
-                   simgrid::ForcefulKillException::do_throw();
-                 }
-                 throw;
-               }
-             });
-           },
-           py::call_guard<GilScopedRelease>(), "Create an actor from a function or an object.")
-      .def_property("host", &Actor::get_host,
-                    [](Actor* a, Host* h) {
-                      GilScopedRelease gil_guard;
-                      a->set_host(h);
-                    },
-                    "The host on which this actor is located")
+                                            "application")
+      .def(
+          "create",
+          [](py::str name, Host* host, py::object fun, py::args args) {
+            fun.inc_ref();  // FIXME: why is this needed for tests like exec-async, exec-dvfs and exec-remote?
+            args.inc_ref(); // FIXME: why is this needed for tests like actor-migrate?
+            return simgrid::s4u::Actor::create(name, host, [fun, args]() {
+              GilScopedAcquire py_context;
+              try {
+                fun(*args);
+              } catch (const py::error_already_set& ex) {
+                bool ffk = ex.matches(pyForcefulKillEx);
+                py_context.reset();
+                if (ffk) {
+                  XBT_VERB("Actor killed");
+                  /* Forward that ForcefulKill exception */
+                  simgrid::ForcefulKillException::do_throw();
+                }
+                throw;
+              }
+            });
+          },
+          py::call_guard<GilScopedRelease>(), "Create an actor from a function or an object.")
+      .def_property(
+          "host", &Actor::get_host,
+          [](Actor* a, Host* h) {
+            GilScopedRelease gil_guard;
+            a->set_host(h);
+          },
+          "The host on which this actor is located")
       .def_property_readonly("name", &Actor::get_cname, "The name of this actor.")
       .def_property_readonly("pid", &Actor::get_pid, "The PID (unique identifier) of this actor.")
       .def_property_readonly("ppid", &Actor::get_ppid,