1 #ifndef SIMGRID_PLUGINS_TASK_H_
2 #define SIMGRID_PLUGINS_TASK_H_
4 #include <simgrid/s4u/Activity.hpp>
5 #include <simgrid/s4u/Io.hpp>
6 #include <xbt/Extendable.hpp>
13 namespace simgrid::plugins {
16 using TaskPtr = boost::intrusive_ptr<Task>;
17 XBT_PUBLIC void intrusive_ptr_release(Task* o);
18 XBT_PUBLIC void intrusive_ptr_add_ref(Task* o);
20 using ExecTaskPtr = boost::intrusive_ptr<ExecTask>;
21 XBT_PUBLIC void intrusive_ptr_release(ExecTask* e);
22 XBT_PUBLIC void intrusive_ptr_add_ref(ExecTask* e);
24 using CommTaskPtr = boost::intrusive_ptr<CommTask>;
25 XBT_PUBLIC void intrusive_ptr_release(CommTask* c);
26 XBT_PUBLIC void intrusive_ptr_add_ref(CommTask* c);
28 using IoTaskPtr = boost::intrusive_ptr<IoTask>;
29 XBT_PUBLIC void intrusive_ptr_release(IoTask* i);
30 XBT_PUBLIC void intrusive_ptr_add_ref(IoTask* i);
32 struct ExtendedAttributeActivity {
33 static simgrid::xbt::Extension<simgrid::s4u::Activity, ExtendedAttributeActivity> EXTENSION_ID;
39 std::set<Task*> successors_ = {};
40 std::map<Task*, unsigned int> predecessors_ = {};
42 void add_predecessor(Task* predecessor);
43 void remove_predecessor(Task* predecessor);
44 bool ready_to_run() const;
45 void receive(Task* source);
51 int queued_execs_ = 0;
53 bool working_ = false;
54 s4u::ActivityPtr current_activity_;
55 std::vector<std::function<void(Task*)>> end_func_handlers_;
56 std::vector<std::function<void(Task*)>> start_func_handlers_;
57 explicit Task(const std::string& name);
58 virtual ~Task() = default;
59 virtual void fire() = 0;
61 static xbt::signal<void(Task*)> on_start;
62 static xbt::signal<void(Task*)> on_end;
63 std::atomic_int_fast32_t refcount_{0};
67 const std::string& get_name() const { return name_; }
68 const char* get_cname() const { return name_.c_str(); }
69 void enqueue_execs(int n);
70 void set_amount(double amount);
71 double get_amount() const { return amount_; }
72 void add_successor(TaskPtr t);
73 void remove_successor(TaskPtr t);
74 void remove_all_successors();
75 const std::set<Task*>& get_successors() const { return successors_; }
76 void on_this_start(const std::function<void(Task*)>& func);
77 void on_this_end(const std::function<void(Task*)>& func);
78 int get_count() const;
80 /** Add a callback fired before a task activity start.
81 * Triggered after the on_this_start function**/
82 static void on_start_cb(const std::function<void(Task*)>& cb) { on_start.connect(cb); }
83 /** Add a callback fired after a task activity end.
84 * Triggered after the on_this_end function, but before
85 * sending tokens to successors.**/
86 static void on_end_cb(const std::function<void(Task*)>& cb) { on_end.connect(cb); }
89 friend void intrusive_ptr_release(Task* o)
91 if (o->refcount_.fetch_sub(1, std::memory_order_release) == 1) {
92 std::atomic_thread_fence(std::memory_order_acquire);
96 friend void intrusive_ptr_add_ref(Task* o) { o->refcount_.fetch_add(1, std::memory_order_relaxed); }
100 class ExecTask : public Task {
103 explicit ExecTask(const std::string& name);
104 void fire() override;
107 static ExecTaskPtr init(const std::string& name);
108 static ExecTaskPtr init(const std::string& name, double flops, s4u::Host* host);
109 ExecTaskPtr set_host(s4u::Host* host);
110 s4u::Host* get_host() const { return host_; }
111 ExecTaskPtr set_flops(double flops);
112 double get_flops() const { return get_amount(); }
113 friend void inline intrusive_ptr_release(ExecTask* e) { intrusive_ptr_release(static_cast<Task*>(e)); }
114 friend void inline intrusive_ptr_add_ref(ExecTask* e) { intrusive_ptr_add_ref(static_cast<Task*>(e)); }
117 class CommTask : public Task {
119 s4u::Host* destination_;
121 explicit CommTask(const std::string& name);
122 void fire() override;
125 static CommTaskPtr init(const std::string& name);
126 static CommTaskPtr init(const std::string& name, double bytes, s4u::Host* source, s4u::Host* destination);
127 CommTaskPtr set_source(s4u::Host* source);
128 s4u::Host* get_source() const { return source_; }
129 CommTaskPtr set_destination(s4u::Host* destination);
130 s4u::Host* get_destination() const { return destination_; }
131 CommTaskPtr set_bytes(double bytes);
132 double get_bytes() const { return get_amount(); }
133 friend void inline intrusive_ptr_release(CommTask* c) { intrusive_ptr_release(static_cast<Task*>(c)); }
134 friend void inline intrusive_ptr_add_ref(CommTask* c) { intrusive_ptr_add_ref(static_cast<Task*>(c)); }
137 class IoTask : public Task {
139 s4u::Io::OpType type_;
140 explicit IoTask(const std::string& name);
141 void fire() override;
144 static IoTaskPtr init(const std::string& name);
145 static IoTaskPtr init(const std::string& name, double bytes, s4u::Disk* disk, s4u::Io::OpType type);
146 IoTaskPtr set_disk(s4u::Disk* disk);
147 s4u::Disk* get_disk() const { return disk_; }
148 IoTaskPtr set_bytes(double bytes);
149 double get_bytes() { return get_amount(); }
150 IoTaskPtr set_op_type(s4u::Io::OpType type);
151 s4u::Io::OpType get_op_type() { return type_; }
153 friend void inline intrusive_ptr_release(IoTask* i) { intrusive_ptr_release(static_cast<Task*>(i)); }
154 friend void inline intrusive_ptr_add_ref(IoTask* i) { intrusive_ptr_add_ref(static_cast<Task*>(i)); }
156 } // namespace simgrid::plugins