----------------------------------------------------------------------------
S4U:
- - kill Comm::on_completion that was not working anyway.
+ - kill signal Comm::on_completion that was not working anyway.
+ - Expose signals Activity::on_suspend and Activity::on_resume
SimGrid (3.31) March 22. 2022.
.. doxygenfunction:: simgrid::s4u::Activity::resume
.. doxygenfunction:: simgrid::s4u::Activity::is_suspended
+Signals
+-------
+
+.. tabs::
+
+ .. group-tab:: C++
+
+ .. doxygenfunction:: simgrid::s4u::Activity::on_completion_cb
+ .. doxygenfunction:: simgrid::s4u::Activity::on_suspend_cb
+ .. doxygenfunction:: simgrid::s4u::Activity::on_resume_cb
+
.. _API_s4u_Comm:
=============
* That is, activities are all the things that do take time to the actor in the simulated world.
*/
class XBT_PUBLIC Activity : public xbt::Extendable<Activity> {
+#ifndef DOXYGEN
friend Comm;
friend Exec;
friend Io;
-#ifndef DOXYGEN
+ friend kernel::activity::ActivityImpl;
friend std::vector<ActivityPtr> create_DAG_from_dot(const std::string& filename);
friend std::vector<ActivityPtr> create_DAG_from_DAX(const std::string& filename);
#endif
private:
static xbt::signal<void(Activity&)> on_veto;
- static xbt::signal<void(Activity&)> on_completion;
+ static xbt::signal<void(Activity const&)> on_completion;
+ static xbt::signal<void(Activity const&)> on_suspended;
+ static xbt::signal<void(Activity const&)> on_resumed;
public:
/*! Add a callback fired each time that the activity fails to start because of a veto (e.g., unsolved dependency or no
static void on_veto_cb(const std::function<void(Activity&)>& cb) { on_veto.connect(cb); }
/*! Add a callback fired when the activity completes (either normally, cancelled or failed) */
static void on_completion_cb(const std::function<void(Activity const&)>& cb) { on_completion.connect(cb); }
+ /*! Add a callback fired when the activity is suspended */
+ static void on_suspended_cb(const std::function<void(Activity const&)>& cb) { on_suspended.connect(cb); }
+ /*! Add a callback fired when the activity is resumed after being suspended */
+ static void on_resumed_cb(const std::function<void(Activity const&)>& cb) { on_resumed.connect(cb); }
void vetoable_start()
{
* under the terms of the license (GNU LGPL) which comes with this package. */
#include <simgrid/modelchecker.h>
+#include <simgrid/s4u/Activity.hpp>
#include <simgrid/s4u/Engine.hpp>
#include "src/kernel/activity/ActivityImpl.hpp"
return;
XBT_VERB("This activity is suspended (remain: %f)", surf_action_->get_remains());
surf_action_->suspend();
- on_suspended(*this);
+ s4u::Activity::on_suspended(*get_iface());
}
void ActivityImpl::resume()
return;
XBT_VERB("This activity is resumed (remain: %f)", surf_action_->get_remains());
surf_action_->resume();
- on_resumed(*this);
+ s4u::Activity::on_resumed(*get_iface());
}
void ActivityImpl::cancel()
delete activity;
}
}
-xbt::signal<void(ActivityImpl const&)> ActivityImpl::on_resumed;
-xbt::signal<void(ActivityImpl const&)> ActivityImpl::on_suspended;
}
}
} // namespace simgrid::kernel::activity::
friend XBT_PUBLIC void intrusive_ptr_add_ref(ActivityImpl* activity);
friend XBT_PUBLIC void intrusive_ptr_release(ActivityImpl* activity);
int get_refcount() const { return static_cast<int>(refcount_); } // For debugging purpose
-
- static xbt::signal<void(ActivityImpl const&)> on_suspended;
- static xbt::signal<void(ActivityImpl const&)> on_resumed;
};
/* This class exists to allow chained setters as in exec->set_name()->set_priority()->set_blah()
}
}
-static s4u::VirtualMachine* get_vm_from_activity(kernel::activity::ActivityImpl const& act)
+static s4u::VirtualMachine* get_vm_from_activity(s4u::Activity const& act)
{
- auto* exec = dynamic_cast<kernel::activity::ExecImpl const*>(&act);
+ auto* exec = dynamic_cast<kernel::activity::ExecImpl const*>(act.get_impl());
return exec != nullptr ? dynamic_cast<s4u::VirtualMachine*>(exec->get_host()) : nullptr;
}
-static void add_active_activity(kernel::activity::ActivityImpl const& act)
+static void add_active_activity(s4u::Activity const& act)
{
const s4u::VirtualMachine* vm = get_vm_from_activity(act);
if (vm != nullptr) {
}
}
-static void remove_active_activity(kernel::activity::ActivityImpl const& act)
+static void remove_active_activity(s4u::Activity const& act)
{
const s4u::VirtualMachine* vm = get_vm_from_activity(act);
if (vm != nullptr) {
s4u::Host::on_state_change_cb(host_state_change);
s4u::Exec::on_start_cb(add_active_exec);
s4u::Activity::on_completion_cb(remove_active_exec);
- activity::ActivityImpl::on_resumed.connect(add_active_activity);
- activity::ActivityImpl::on_suspended.connect(remove_active_activity);
+ s4u::Activity::on_resumed_cb(add_active_activity);
+ s4u::Activity::on_suspended_cb(remove_active_activity);
}
double VMModel::next_occurring_event(double now)
namespace s4u {
xbt::signal<void(Activity&)> Activity::on_veto;
-xbt::signal<void(Activity&)> Activity::on_completion;
+xbt::signal<void(Activity const&)> Activity::on_completion;
+xbt::signal<void(Activity const&)> Activity::on_suspended;
+xbt::signal<void(Activity const&)> Activity::on_resumed;
std::set<Activity*>* Activity::vetoed_activities_ = nullptr;