.. doxygenfunction:: simgrid::s4u::Disk::set_property(const std::string &, const std::string &value)
.. doxygenfunction:: simgrid::s4u::Disk::set_sharing_policy
+ .. doxygenenum:: simgrid::s4u::Disk::Operation
+ .. doxygenenum:: simgrid::s4u::Disk::SharingPolicy
+
.. group-tab:: Python
.. autoattribute:: simgrid.Disk.name
.. automethod:: simgrid.Disk.set_sharing_policy
+ .. autoclass:: simgrid.Disk.Operation
+ .. autoclass:: simgrid.Disk.SharingPolicy
+
I/O operations
--------------
.. group-tab:: C++
- .. doxygenfunction:: simgrid::s4u::Link::get_bandwidth() const
.. doxygenfunction:: simgrid::s4u::Link::get_cname() const
- .. doxygenfunction:: simgrid::s4u::Link::get_latency() const
.. doxygenfunction:: simgrid::s4u::Link::get_name() const
- .. doxygenfunction:: simgrid::s4u::Link::get_sharing_policy() const
- .. doxygenfunction:: simgrid::s4u::Link::get_concurrency_limit() const
.. doxygenfunction:: simgrid::s4u::Link::get_load() const
.. doxygenfunction:: simgrid::s4u::Link::is_used() const
.. group-tab:: Python
- .. autoattribute:: simgrid.Link.bandwidth
- .. autoattribute:: simgrid.Link.latency
+ .. autoattribute:: simgrid.Link.name
.. group-tab:: C
- .. doxygenfunction:: sg_link_get_bandwidth(const_sg_link_t link)
- .. doxygenfunction:: sg_link_get_latency(const_sg_link_t link)
.. doxygenfunction:: sg_link_get_name(const_sg_link_t link)
.. doxygenfunction:: sg_link_is_shared(const_sg_link_t link)
-Modifying characteristics
--------------------------
+Performance
+-----------
.. tabs::
.. group-tab:: C++
+ .. doxygenfunction:: simgrid::s4u::Link::get_bandwidth() const
+ .. doxygenfunction:: simgrid::s4u::Link::get_latency() const
.. doxygenfunction:: simgrid::s4u::Link::set_bandwidth(double value)
.. doxygenfunction:: simgrid::s4u::Link::set_latency(double value)
.. doxygenfunction:: simgrid::s4u::Link::set_latency(const std::string& value)
- .. doxygenfunction:: simgrid::s4u::Link::set_concurrency_limit(int limit)
- .. doxygenfunction:: simgrid::s4u::Link::set_sharing_policy
.. group-tab:: Python
+ .. autoattribute:: simgrid.Link.bandwidth
+ .. autoattribute:: simgrid.Link.latency
.. automethod:: simgrid.Link.set_bandwidth
.. automethod:: simgrid.Link.set_latency
- .. automethod:: simgrid.Link.set_concurrency_limit
- .. automethod:: simgrid.Link.set_sharing_policy
.. group-tab:: C
+ .. doxygenfunction:: sg_link_get_bandwidth(const_sg_link_t link)
+ .. doxygenfunction:: sg_link_get_latency(const_sg_link_t link)
.. doxygenfunction:: sg_link_set_bandwidth(sg_link_t link, double value)
.. doxygenfunction:: sg_link_set_latency(sg_link_t link, double value)
+Model policy
+------------
+
+.. tabs::
+
+ .. group-tab:: C++
+
+ .. doxygenenum:: simgrid::s4u::Link::SharingPolicy
+
+ .. doxygenfunction:: simgrid::s4u::Link::get_sharing_policy() const
+ .. doxygenfunction:: simgrid::s4u::Link::set_sharing_policy
+
+ .. doxygenfunction:: simgrid::s4u::Link::get_concurrency_limit() const
+ .. doxygenfunction:: simgrid::s4u::Link::set_concurrency_limit(int limit)
+
+ .. group-tab:: Python
+
+ .. automethod:: simgrid.Link.set_concurrency_limit
+ .. automethod:: simgrid.Link.set_sharing_policy
+
+ .. group-tab:: C
+
+
User data and properties
------------------------
.. doxygenfunction:: simgrid::s4u::Task::get_cname() const
.. doxygenfunction:: simgrid::s4u::Task::get_name() const
- .. doxygenfunction:: simgrid::s4u::Task::get_count() const
- .. doxygenfunction:: simgrid::s4u::Task::get_amount() const
- .. doxygenfunction:: simgrid::s4u::Task::get_parallelism_degree() const
+ .. doxygenfunction:: simgrid::s4u::Task::get_count(std::string instance) const
+ .. doxygenfunction:: simgrid::s4u::Task::get_amount(std::string instance) const
+ .. doxygenfunction:: simgrid::s4u::Task::get_queued_firings(std::string instance) const
+ .. doxygenfunction:: simgrid::s4u::Task::get_running_count(std::string instance) const
+ .. doxygenfunction:: simgrid::s4u::Task::get_parallelism_degree(std::string instance) const
.. doxygenfunction:: simgrid::s4u::Task::set_name(std::string name)
- .. doxygenfunction:: simgrid::s4u::Task::set_amount(double amount)
- .. doxygenfunction:: simgrid::s4u::Task::set_parallelism_degree(int n)
Life cycle
----------
.. group-tab:: C++
.. doxygenfunction:: simgrid::s4u::Task::enqueue_firings(int n)
+ .. doxygenfunction:: simgrid::s4u::Task::set_amount(double amount, std::string instance)
+ .. doxygenfunction:: simgrid::s4u::Task::set_parallelism_degree(int n, std::string instance)
Managing Dependencies
---------------------
+
.. tabs::
.. group-tab:: C++
Managing Tokens
---------------
+
.. doxygenclass:: simgrid::s4u::Token
.. tabs::
.. group-tab:: C++
- .. doxygenfunction:: simgrid::s4u::Task::get_next_token_from(TaskPtr t)
+ .. doxygenfunction:: simgrid::s4u::Task::get_token_from(TaskPtr t) const
+ .. doxygenfunction:: simgrid::s4u::Task::get_tokens_from(TaskPtr t) const
+ .. doxygenfunction:: simgrid::s4u::Task::deque_token_from(TaskPtr t)
.. doxygenfunction:: simgrid::s4u::Task::set_token(std::shared_ptr<Token> token)
Signals
.. group-tab:: C++
- .. doxygenfunction:: simgrid::s4u::ExecTask::get_host() const
- .. doxygenfunction:: simgrid::s4u::ExecTask::get_flops() const
- .. doxygenfunction:: simgrid::s4u::ExecTask::set_host(Host* host);
- .. doxygenfunction:: simgrid::s4u::ExecTask::set_flops(double flops);
+ .. doxygenfunction:: simgrid::s4u::ExecTask::get_host(std::string instance) const
+ .. doxygenfunction:: simgrid::s4u::ExecTask::get_flops(std::string instance) const
+ .. doxygenfunction:: simgrid::s4u::ExecTask::set_host(Host* host, std::string instance);
+ .. doxygenfunction:: simgrid::s4u::ExecTask::set_flops(double flops, std::string instance);
+ .. doxygenfunction:: simgrid::s4u::ExecTask::add_instances(int n);
+ .. doxygenfunction:: simgrid::s4u::ExecTask::remove_instances(int n);
.. _API_s4u_IoTask:
#ifndef SIMGRID_S4U_TASK_H_
#define SIMGRID_S4U_TASK_H_
+ #include <simgrid/forward.h>
#include <simgrid/s4u/Activity.hpp>
#include <simgrid/s4u/Io.hpp>
#include <xbt/Extendable.hpp>
namespace simgrid::s4u {
- class Task;
- using TaskPtr = boost::intrusive_ptr<Task>;
- XBT_PUBLIC void intrusive_ptr_release(Task* o);
- XBT_PUBLIC void intrusive_ptr_add_ref(Task* o);
- class ExecTask;
- using ExecTaskPtr = boost::intrusive_ptr<ExecTask>;
- class CommTask;
- using CommTaskPtr = boost::intrusive_ptr<CommTask>;
- class IoTask;
- using IoTaskPtr = boost::intrusive_ptr<IoTask>;
-
class XBT_PUBLIC Token : public xbt::Extendable<Token> {};
- class Task {
+ /** Task class */
+ class XBT_PUBLIC Task {
std::string name_;
virtual void fire(std::string instance);
void complete(std::string instance);
- void store_activity(ActivityPtr a, std::string instance) { current_activities_[instance].push_back(a); }
+ void store_activity(ActivityPtr a, const std::string& instance) { current_activities_[instance].push_back(a); }
virtual void add_instances(int n);
virtual void remove_instances(int n);
public:
+ /** @param name The new name of this Task */
void set_name(std::string name);
+ /** Retrieves the name of that Task as a C++ string */
const std::string& get_name() const { return name_; }
+ /** Retrieves the name of that Task as a C string */
const char* get_cname() const { return name_.c_str(); }
+ /** @param amount The new amount of work this instance of this Task has to do
+ * @note In flops for ExecTasks instances and in bytes for CommTasks instances. In flops for dispatcher and collector
+ * instances */
void set_amount(double amount, std::string instance = "instance_0");
+ /** @return Amout of work this instance of this Task has to process */
double get_amount(std::string instance = "instance_0") const { return amount_.at(instance); }
- int get_queued_firings(std::string instance = "instance_0") { return queued_firings_.at(instance); }
- int get_running_count(std::string instance = "instance_0") { return running_instances_.at(instance); }
+ /** @return Amount of queued firings for this instance of this Task */
+ int get_queued_firings(std::string instance = "instance_0") const { return queued_firings_.at(instance); }
+ /** @return Amount currently running of this instance of this Task */
+ int get_running_count(std::string instance = "instance_0") const { return running_instances_.at(instance); }
+ /** @return Number of times this instance of this Task has been completed */
int get_count(std::string instance = "collector") const { return count_.at(instance); }
+ /** @param n The parallelism degree to set
+ * @brief The parallelism degree defines how many of this instance can run in parallel. */
void set_parallelism_degree(int n, std::string instance = "all");
+ /** @return Parallelism degree of this instance of this Task */
int get_parallelism_degree(std::string instance = "instance_0") const { return parallelism_degree_.at(instance); }
+ /** @param bytes The amount of bytes this instance has to send to the next instance of this Task
+ * @note This amount is used when the host is different between the dispatcher and the instance doing the work of the
+ * Task, or between the instance and the collector. */
void set_internal_bytes(int bytes, std::string instance = "instance_0");
+ /** @return Amount of bytes this instance of the Task has to send to the next instance */
double get_internal_bytes(std::string instance = "instance_0") const { return internal_bytes_to_send_.at(instance); }
+ /** @param func The new balancing function
+ * @note This function is used by the dispatcher to determine which instance will effectively do the work. This
+ * function must return the name of the instance as a string. The default balancing function always returns
+ * "instance_0" */
void set_load_balancing_function(std::function<std::string()> func);
-
+ /** @param token The new token */
void set_token(std::shared_ptr<Token> token);
+ /** @param t A Smart pointer to a Task
+ * @return Oldest token received by this Task that was sent by Task t */
std::shared_ptr<Token> get_token_from(TaskPtr t) const { return tokens_received_.at(t).front(); }
+ /** @param t A Smart pointer to a Task
+ * @return All tokens received by this Task that were sent by Task t */
std::deque<std::shared_ptr<Token>> get_tokens_from(TaskPtr t) const { return tokens_received_.at(t); }
+ /** @param t A Smart pointer to a Task
+ * @brief Pop the oldest token received by this Task that was sent by Task t */
void deque_token_from(TaskPtr t);
-
+ /** @param t A Smart pointer to a Task
+ * @brief Add t as a successor of this Task */
void add_successor(TaskPtr t);
+ /** @param t A Smart pointer to a Task
+ * @brief Remove t from the successors of this Task */
void remove_successor(TaskPtr t);
+ /** @brief Remove all successors from this Task */
void remove_all_successors();
+ /** @return All successors of this Task */
const std::set<Task*>& get_successors() const { return successors_; }
-
+ /** @param n The number of firings to enqueue */
void enqueue_firings(int n);
-
/** Add a callback fired before this task activity starts */
void on_this_start_cb(const std::function<void(Task*)>& func) { on_this_start.connect(func); }
/** Add a callback fired before a task activity starts.
#endif
};
+ /** CommTask class */
class CommTask : public Task {
Host* source_;
Host* destination_;
static CommTaskPtr init(const std::string& name);
static CommTaskPtr init(const std::string& name, double bytes, Host* source, Host* destination);
+ /** @param source The new source Host of this CommTask
+ * @return A Smart pointer to this CommTask */
CommTaskPtr set_source(Host* source);
+ /** @return A pointer to the source Host of this CommTask */
Host* get_source() const { return source_; }
+ /** @param destination The new destination of this CommTask
+ * @return A Smart pointer to the destination Host of this CommTask */
CommTaskPtr set_destination(Host* destination);
+ /** @return A pointer to the destination Host of this CommTask */
Host* get_destination() const { return destination_; }
+ /** @param bytes The amount of bytes this CommTask has to send */
CommTaskPtr set_bytes(double bytes);
+ /** @return The amout of bytes this CommTask has to send */
double get_bytes() const { return get_amount("instance_0"); }
};
+ /** ExecTask class */
class ExecTask : public Task {
std::map<std::string, Host*> host_ = {{"instance_0", nullptr}, {"dispatcher", nullptr}, {"collector", nullptr}};
static ExecTaskPtr init(const std::string& name);
static ExecTaskPtr init(const std::string& name, double flops, Host* host);
+ /** @param host The new host of this instance of this ExecTask
+ * @return a Smart pointer to this ExecTask */
ExecTaskPtr set_host(Host* host, std::string instance = "all");
+ /** @return A pointer to the host of this instance of this ExecTask */
Host* get_host(std::string instance = "instance_0") const { return host_.at(instance); }
+ /** @param flops The new amount of flops this instance of this Task has to execute
+ * @return A Smart pointer to this ExecTask */
ExecTaskPtr set_flops(double flops, std::string instance = "instance_0");
+ /** @return The amount of flops this instance of this ExecTask has to execute */
double get_flops(std::string instance = "instance_0") const { return get_amount(instance); }
-
+ /** @param n The number of instances to add to this ExecTask */
void add_instances(int n) override;
+ /** @param n The number of isntances to remove from this ExecTask */
void remove_instances(int n) override;
};
+ /** IoTask class */
class IoTask : public Task {
Disk* disk_;
Io::OpType type_;
static IoTaskPtr init(const std::string& name);
static IoTaskPtr init(const std::string& name, double bytes, Disk* disk, Io::OpType type);
+ /** @param disk The new disk of this IoTask
+ * @return A Smart pointer to this IoTask */
IoTaskPtr set_disk(Disk* disk);
+ /** @return A pointer to the disk of this IoTask */
Disk* get_disk() const { return disk_; }
+ /** @param bytes The new amount of bytes this IoTask has to write or read
+ * @return A Smart pointer to this IoTask */
IoTaskPtr set_bytes(double bytes);
+ /** @return The amount of bytes this IoTask has to write or read */
double get_bytes() const { return get_amount("instance_0"); }
+ /** @param type The type of operation this IoTask has to do
+ * @return A Smart pointer to this IoTask */
IoTaskPtr set_op_type(Io::OpType type);
+ /** @return The type of operation this IoTask has to to */
Io::OpType get_op_type() const { return type_; }
};
} // namespace simgrid::s4u
