* - Synchronization activities may possibly be connected to no action.
*/
class XBT_PUBLIC Activity {
+#ifndef DOXYGEN
friend Comm;
friend XBT_PUBLIC void intrusive_ptr_release(Comm * c);
friend XBT_PUBLIC void intrusive_ptr_add_ref(Comm * c);
friend Io;
friend XBT_PUBLIC void intrusive_ptr_release(Io* i);
friend XBT_PUBLIC void intrusive_ptr_add_ref(Io* i);
+#endif
protected:
Activity() = default;
namespace simgrid {
namespace s4u {
-/** @ingroup s4u_api
+/**
*
* An actor is an independent stream of execution in your distributed application.
*
/** @brief Simulation Agent */
class XBT_PUBLIC Actor : public simgrid::xbt::Extendable<Actor> {
+#ifndef DOXYGEN
friend Exec;
friend Mailbox;
friend simgrid::kernel::actor::ActorImpl;
friend simgrid::kernel::activity::MailboxImpl;
+#endif
kernel::actor::ActorImpl* pimpl_ = nullptr;
/** Wrap a (possibly non-copyable) single-use task into a `std::function` */
/** Signal indicating that the given actor is about to disappear */
static simgrid::xbt::signal<void(simgrid::s4u::ActorPtr)> on_destruction;
- /** Create an actor using a function
+ /** Create an actor from a std::function
*
* If the actor is restarted, the actor has a fresh copy of the function.
*/
static ActorPtr create(std::string name, s4u::Host* host, std::function<void()> code);
+ /** Create an actor from a std::function
+ *
+ * If the actor is restarted, the actor has a fresh copy of the function.
+ */
static ActorPtr create(std::string name, s4u::Host* host, std::function<void(std::vector<std::string>*)> code,
std::vector<std::string>* args)
{
/** Retrieves the time at which that actor will be killed (or -1 if not set) */
double get_kill_time();
+ /** @brief Moves the actor to another host
+ *
+ * If the actor is currently blocked on an execution activity, the activity is also
+ * migrated to the new host. If it's blocked on another kind of activity, an error is
+ * raised as the mandated code is not written yet. Please report that bug if you need it.
+ *
+ * Asynchronous activities started by the actor are not migrated automatically, so you have
+ * to take care of this yourself (only you knows which ones should be migrated).
+ */
void migrate(Host * new_host);
/** Ask the actor to die.
/** Retrieves the actor that have the given PID (or nullptr if not existing) */
static ActorPtr by_pid(aid_t pid);
- /** @brief Wait for the actor to finish.
+ /** Wait for the actor to finish.
*
* This blocks the calling actor until the actor on which we call join() is terminated
*/
const char* get_property(std::string key);
void set_property(std::string key, std::string value);
+#ifndef DOXYGEN
/** @deprecated See Actor::create() */
XBT_ATTRIB_DEPRECATED_v323("Please use Actor::create()") static ActorPtr createActor(
const char* name, s4u::Host* host, std::function<void()> code)
{
set_property(key, value);
}
+#endif
};
/** @ingroup s4u_api
/** @brief kill the actor. */
XBT_PUBLIC void exit();
+#ifndef DOXYGEN
/** @deprecated Please use std::function<void(int, void*)> for first parameter */
XBT_ATTRIB_DEPRECATED_v323("Please use std::function<void(int, void*)> for first parameter.") XBT_PUBLIC
void on_exit(int_f_pvoid_pvoid_t fun, void* data);
XBT_ATTRIB_DEPRECATED_v323("Please use this_actor::on_exit()") XBT_PUBLIC void onExit(int_f_pvoid_pvoid_t fun, void* data);
/** @deprecated See this_actor::exit() */
XBT_ATTRIB_DEPRECATED_v324("Please use this_actor::exit()") XBT_PUBLIC void kill();
+#endif
}
/** @} */
*/
class XBT_PUBLIC ConditionVariable {
private:
+#ifndef DOXYGEN
friend kernel::activity::ConditionVariableImpl;
smx_cond_t cond_;
+#endif
explicit ConditionVariable(smx_cond_t cond) : cond_(cond) {}
public:
ConditionVariable(ConditionVariable const&) = delete;
void load_deployment(std::string deploy);
protected:
- friend s4u::Host;
- friend s4u::Link;
- friend s4u::Storage;
+#ifndef DOXYGEN
+ friend Host;
+ friend Link;
+ friend Storage;
friend kernel::routing::NetPoint;
friend kernel::routing::NetZoneImpl;
friend kernel::resource::LinkImpl;
- void host_register(std::string name, simgrid::s4u::Host* host);
+ void host_register(std::string name, Host* host);
void host_unregister(std::string name);
- void link_register(std::string name, simgrid::s4u::Link* link);
+ void link_register(std::string name, Link* link);
void link_unregister(std::string name);
- void storage_register(std::string name, simgrid::s4u::Storage* storage);
+ void storage_register(std::string name, Storage* storage);
void storage_unregister(std::string name);
void netpoint_register(simgrid::kernel::routing::NetPoint* card);
void netpoint_unregister(simgrid::kernel::routing::NetPoint* card);
+#endif /*DOXYGEN*/
public:
size_t get_host_count();
+ /** @brief Returns the list of all hosts found in the platform */
std::vector<Host*> get_all_hosts();
std::vector<Host*> get_filtered_hosts(std::function<bool(Host*)> filter);
simgrid::s4u::Host* host_by_name(std::string name);
namespace simgrid {
namespace s4u {
+/** Computation #Activity, representing the asynchronous disk access.
+ *
+ * They are generated from simgrid::s4u::this_actor::exec_init() or simgrid::s4u::Host::execute().
+ */
+
class XBT_PUBLIC Exec : public Activity {
Exec() : Activity() {}
public:
* and actors can retrieve the host on which they run using simgrid::s4u::Host::current().
*/
class XBT_PUBLIC Host : public simgrid::xbt::Extendable<Host> {
+#ifndef DOXYGEN
friend simgrid::vm::VMModel; // Use the pimpl_cpu to compute the VM sharing
friend simgrid::vm::VirtualMachineImpl; // creates the the pimpl_cpu
+#endif
public:
explicit Host(std::string name);
namespace simgrid {
namespace s4u {
+/** I/O Activity, representing the asynchronous disk access.
+ *
+ * They are generated from simgrid::s4u::Storage::read() and simgrid::s4u::Storage::write().
+ */
+
class XBT_PUBLIC Io : public Activity {
public:
enum class OpType { READ, WRITE };
namespace s4u {
/** @brief A Link represents the network facilities between [hosts](@ref simgrid::s4u::Host) */
class XBT_PUBLIC Link : public simgrid::xbt::Extendable<Link> {
+#ifndef DOXYGEN
friend simgrid::kernel::resource::LinkImpl;
+#endif
// Links are created from the NetZone, and destroyed by their private implementation when the simulation ends
explicit Link(kernel::resource::LinkImpl* pimpl) : pimpl_(pimpl) {}
* @section s4u_mb_api The API
*/
class XBT_PUBLIC Mailbox {
+#ifndef DOXYGEN
friend Comm;
friend simgrid::kernel::activity::MailboxImpl;
+#endif
simgrid::kernel::activity::MailboxImpl* pimpl_;
*
*/
class XBT_PUBLIC Mutex {
+#ifndef DOXYGEN
friend ConditionVariable;
friend simgrid::kernel::activity::MutexImpl;
+#endif
simgrid::kernel::activity::MutexImpl* pimpl_;
explicit Mutex(simgrid::kernel::activity::MutexImpl* mutex) : pimpl_(mutex) {}
*/
class XBT_PUBLIC NetZone {
protected:
+#ifndef DOXYGEN
friend simgrid::kernel::routing::NetZoneImpl;
+#endif
explicit NetZone(kernel::routing::NetZoneImpl* impl);
~NetZone();
#include <unordered_map>
namespace simgrid {
-namespace xbt {
-extern template class XBT_PUBLIC Extendable<simgrid::s4u::Storage>;
-}
namespace s4u {
+#ifndef DOXYGEN
/** @deprecated Engine::get_all_storages() */
XBT_ATTRIB_DEPRECATED_v322("Please use Engine::get_all_storages()") XBT_PUBLIC void getStorageList(std::map<std::string, Storage*>* whereTo);
+#endif
+
+/** Storage represent the disk resources, usually associated to a given host */
class XBT_PUBLIC Storage : public simgrid::xbt::Extendable<Storage> {
+#ifndef DOXYGEN
friend s4u::Engine;
friend s4u::Io;
friend simgrid::surf::StorageImpl;
+#endif /* DOXYGEN */
public:
explicit Storage(std::string name, surf::StorageImpl * pimpl);
simgrid::simix::simcall([this, fun, data] { SIMIX_process_on_exit(pimpl_, fun, data); });
}
-/** @brief Moves the actor to another host
- *
- * If the actor is currently blocked on an execution activity, the activity is also
- * migrated to the new host. If it's blocked on another kind of activity, an error is
- * raised as the mandated code is not written yet. Please report that bug if you need it.
- *
- * Asynchronous activities started by the actor are not migrated automatically, so you have
- * to take care of this yourself (only you knows which ones should be migrated).
- */
void Actor::migrate(Host* new_host)
{
s4u::Actor::on_migration_start(this);
list->push_back(kv.second);
}
-/** @brief Returns the list of all hosts found in the platform */
std::vector<Host*> Engine::get_all_hosts()
{
std::vector<Host*> res;
