/* 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. */
-#ifndef SIMIX_ACTORIMPL_H
-#define SIMIX_ACTORIMPL_H
+#ifndef SIMGRID_KERNEL_ACTOR_ACTORIMPL_HPP
+#define SIMGRID_KERNEL_ACTOR_ACTORIMPL_HPP
#include "simgrid/s4u/Actor.hpp"
#include "src/simix/popping_private.hpp"
-#include "src/surf/PropertyHolder.hpp"
+#include "xbt/PropertyHolder.hpp"
#include <boost/intrusive/list.hpp>
#include <functional>
#include <list>
namespace kernel {
namespace actor {
-class XBT_PUBLIC ActorImpl : public surf::PropertyHolder {
+class XBT_PUBLIC ActorImpl : public xbt::PropertyHolder {
s4u::Host* host_ = nullptr; /* the host on which the actor is running */
+ // XBT_DEPRECATED_v329
void* userdata_ = nullptr; /* kept for compatibility, it should be replaced with moddata */
aid_t pid_ = 0;
aid_t ppid_ = -1;
public:
xbt::string name_;
- ActorImpl(const xbt::string& name, s4u::Host* host);
+ ActorImpl(xbt::string name, s4u::Host* host);
ActorImpl(const ActorImpl&) = delete;
ActorImpl& operator=(const ActorImpl&) = delete;
~ActorImpl();
+ static ActorImpl* self();
double get_kill_time();
void set_kill_time(double kill_time);
- boost::intrusive::list_member_hook<> host_process_list_hook; /* simgrid::simix::Host::process_list */
+ boost::intrusive::list_member_hook<> host_actor_list_hook; /* simgrid::simix::Host::process_list */
boost::intrusive::list_member_hook<> smx_destroy_list_hook; /* simix_global->actors_to_destroy */
boost::intrusive::list_member_hook<> smx_synchro_hook; /* {mutex,cond,sem}->sleeping */
// Accessors to private fields
s4u::Host* get_host() { return host_; }
void set_host(s4u::Host* dest);
+ // XBT_DEPRECATED_v329
void* get_user_data() { return userdata_; }
+ // XBT_DEPRECATED_v329
void set_user_data(void* data) { userdata_ = data; }
aid_t get_pid() const { return pid_; }
aid_t get_ppid() const { return ppid_; }
int get_refcount() { return refcount_; }
friend void intrusive_ptr_add_ref(ActorImpl* actor)
{
- // std::memory_order_relaxed ought to be enough here instead of std::memory_order_seq_cst
- // But then, we have a threading issue when an actor commits a suicide:
- // it seems that in this case, the worker thread kills the last occurrence of the actor
- // while usually, the maestro does so. FIXME: we should change how actors suicide
- actor->refcount_.fetch_add(1, std::memory_order_seq_cst);
+ // This whole memory consistency semantic drives me nuts.
+ // std::memory_order_relaxed proves to not be enough: There is a threading issue when actors commit suicide.
+ // My guess is that the maestro context wants to propagate changes to the actor's fields after the
+ // actor context frees that memory area or something. But I'm not 100% certain of what's going on.
+ // std::memory_order_seq_cst works but that's rather demanding.
+ // AFAIK, std::memory_order_acq_rel works on all tested platforms, so let's stick to it.
+ // Reducing the requirements to _relaxed would require to fix our suicide procedure, which is a messy piece of code.
+ actor->refcount_.fetch_add(1, std::memory_order_acq_rel);
}
friend void intrusive_ptr_release(ActorImpl* actor)
{
private:
s4u::Actor piface_; // Our interface is part of ourselves
+ void cleanup_from_simix();
void undaemonize();
public:
void daemonize();
bool is_suspended() { return suspended_; }
s4u::Actor* restart();
- activity::ActivityImplPtr suspend(ActorImpl* issuer);
+ void suspend();
void resume();
- activity::ActivityImplPtr join(ActorImpl* actor, double timeout);
+ activity::ActivityImplPtr join(const ActorImpl* actor, double timeout);
activity::ActivityImplPtr sleep(double duration);
/** Ask the actor to throw an exception right away */
void throw_exception(std::exception_ptr e);
+
+ /** execute the pending simcall -- must be called from the maestro context */
+ void simcall_handle(int value);
+ /** Terminates a simcall currently executed in maestro context. The actor will be restarted in the next scheduling
+ * round */
+ void simcall_answer();
};
class ProcessArg {
