include/simgrid/plugins/task.hpp

   1 #ifndef SIMGRID_PLUGINS_TASK_H_
   2 #define SIMGRID_PLUGINS_TASK_H_
   3
   4 #include <simgrid/s4u/Activity.hpp>
   5 #include <simgrid/s4u/Io.hpp>
   6 #include <xbt/Extendable.hpp>
   7
   8 #include <atomic>
   9 #include <map>
  10 #include <memory>
  11 #include <set>
  12
  13 namespace simgrid::plugins {
  14
  15 class Task;
  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);
  19 class ExecTask;
  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);
  23 class CommTask;
  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);
  27 class IoTask;
  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);
  31
  32 struct ExtendedAttributeActivity {
  33   static simgrid::xbt::Extension<simgrid::s4u::Activity, ExtendedAttributeActivity> EXTENSION_ID;
  34   Task* task_;
  35 };
  36
  37 class Task {
  38   static bool inited_;
  39   std::set<Task*> successors_                 = {};
  40   std::map<Task*, unsigned int> predecessors_ = {};
  41
  42   void add_predecessor(Task* predecessor);
  43   void remove_predecessor(Task* predecessor);
  44   bool ready_to_run() const;
  45   void receive(Task* source);
  46   void complete();
  47
  48 protected:
  49   std::string name_;
  50   double amount_;
  51   int queued_execs_ = 0;
  52   int count_        = 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;
  60
  61   static xbt::signal<void(Task*)> on_start;
  62   static xbt::signal<void(Task*)> on_end;
  63   std::atomic_int_fast32_t refcount_{0};
  64
  65 public:
  66   static void init();
  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;
  79
  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); }
  87
  88 #ifndef DOXYGEN
  89   friend void intrusive_ptr_release(Task* o)
  90   {
  91     if (o->refcount_.fetch_sub(1, std::memory_order_release) == 1) {
  92       std::atomic_thread_fence(std::memory_order_acquire);
  93       delete o;
  94     }
  95   }
  96   friend void intrusive_ptr_add_ref(Task* o) { o->refcount_.fetch_add(1, std::memory_order_relaxed); }
  97 #endif
  98 };
  99
 100 class ExecTask : public Task {
 101   s4u::Host* host_;
 102
 103   explicit ExecTask(const std::string& name);
 104   void fire() override;
 105
 106 public:
 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)); }
 115 };
 116
 117 class CommTask : public Task {
 118   s4u::Host* source_;
 119   s4u::Host* destination_;
 120
 121   explicit CommTask(const std::string& name);
 122   void fire() override;
 123
 124 public:
 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)); }
 135 };
 136
 137 class IoTask : public Task {
 138   s4u::Disk* disk_;
 139   s4u::Io::OpType type_;
 140   explicit IoTask(const std::string& name);
 141   void fire() override;
 142
 143 public:
 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_; }
 152
 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)); }
 155 };
 156 } // namespace simgrid::plugins
 157 #endif