include/simgrid/s4u/Task.hpp

   1 #ifndef SIMGRID_S4U_TASK_H_
   2 #define SIMGRID_S4U_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 <deque>
  10 #include <map>
  11 #include <memory>
  12 #include <set>
  13 #include <xbt/asserts.h>
  14
  15 namespace simgrid::s4u {
  16
  17 class Task;
  18 using TaskPtr = boost::intrusive_ptr<Task>;
  19 XBT_PUBLIC void intrusive_ptr_release(Task* o);
  20 XBT_PUBLIC void intrusive_ptr_add_ref(Task* o);
  21 class ExecTask;
  22 using ExecTaskPtr = boost::intrusive_ptr<ExecTask>;
  23 class CommTask;
  24 using CommTaskPtr = boost::intrusive_ptr<CommTask>;
  25 class IoTask;
  26 using IoTaskPtr = boost::intrusive_ptr<IoTask>;
  27
  28 class XBT_PUBLIC Token : public xbt::Extendable<Token> {};
  29
  30 class Task {
  31
  32   std::string name_;
  33
  34   std::map<std::string, double> amount_              = {{"instance_0", 0}, {"dispatcher", 0}, {"collector", 0}};
  35   std::map<std::string, int> queued_firings_         = {{"instance_0", 0}, {"dispatcher", 0}, {"collector", 0}};
  36   std::map<std::string, int> running_instances_      = {{"instance_0", 0}, {"dispatcher", 0}, {"collector", 0}};
  37   std::map<std::string, int> count_                  = {{"instance_0", 0}, {"dispatcher", 0}, {"collector", 0}};
  38   std::map<std::string, int> parallelism_degree_     = {{"instance_0", 1}, {"dispatcher", 1}, {"collector", 1}};
  39   std::map<std::string, int> internal_bytes_to_send_ = {{"instance_0", 0}, {"dispatcher", 0}};
  40
  41   std::function<std::string()> load_balancing_function_;
  42
  43   std::set<Task*> successors_                 = {};
  44   std::map<Task*, unsigned int> predecessors_ = {};
  45   std::atomic_int_fast32_t refcount_{0};
  46
  47   bool ready_to_run(std::string instance);
  48   void receive(Task* source);
  49
  50   std::shared_ptr<Token> token_ = nullptr;
  51   std::map<TaskPtr, std::deque<std::shared_ptr<Token>>> tokens_received_;
  52   std::map<std::string, std::deque<ActivityPtr>> current_activities_ = {
  53       {"instance_0", {}}, {"dispatcher", {}}, {"collector", {}}};
  54
  55   inline static xbt::signal<void(Task*)> on_start;
  56   xbt::signal<void(Task*)> on_this_start;
  57   inline static xbt::signal<void(Task*)> on_completion;
  58   xbt::signal<void(Task*)> on_this_completion;
  59
  60 protected:
  61   explicit Task(const std::string& name);
  62   virtual ~Task() = default;
  63
  64   virtual void fire(std::string instance);
  65   void complete(std::string instance);
  66
  67   void store_activity(ActivityPtr a, std::string instance) { current_activities_[instance].push_back(a); }
  68
  69   virtual void add_instances(int n);
  70   virtual void remove_instances(int n);
  71
  72 public:
  73   void set_name(std::string name);
  74   const std::string& get_name() const { return name_; }
  75   const char* get_cname() const { return name_.c_str(); }
  76   void set_amount(double amount, std::string instance = "instance_0");
  77   double get_amount(std::string instance = "instance_0") const { return amount_.at(instance); }
  78   int get_queued_firings(std::string instance = "instance_0") { return queued_firings_.at(instance); }
  79   int get_running_count(std::string instance = "instance_0") { return running_instances_.at(instance); }
  80   int get_count(std::string instance = "collector") const { return count_.at(instance); }
  81   void set_parallelism_degree(int n, std::string instance = "all");
  82   int get_parallelism_degree(std::string instance = "instance_0") const { return parallelism_degree_.at(instance); }
  83   void set_internal_bytes(int bytes, std::string instance = "instance_0");
  84   double get_internal_bytes(std::string instance = "instance_0") const { return internal_bytes_to_send_.at(instance); }
  85   void set_load_balancing_function(std::function<std::string()> func);
  86
  87   void set_token(std::shared_ptr<Token> token);
  88   std::shared_ptr<Token> get_token_from(TaskPtr t) const { return tokens_received_.at(t).front(); }
  89   std::deque<std::shared_ptr<Token>> get_tokens_from(TaskPtr t) const { return tokens_received_.at(t); }
  90   void deque_token_from(TaskPtr t);
  91
  92   void add_successor(TaskPtr t);
  93   void remove_successor(TaskPtr t);
  94   void remove_all_successors();
  95   const std::set<Task*>& get_successors() const { return successors_; }
  96
  97   void enqueue_firings(int n);
  98
  99   /** Add a callback fired before this task activity starts */
 100   void on_this_start_cb(const std::function<void(Task*)>& func) { on_this_start.connect(func); }
 101   /** Add a callback fired before a task activity starts.
 102    * Triggered after the on_this_start function**/
 103   static void on_start_cb(const std::function<void(Task*)>& cb) { on_start.connect(cb); }
 104   /** Add a callback fired before this task activity ends */
 105   void on_this_completion_cb(const std::function<void(Task*)>& func) { on_this_completion.connect(func); };
 106   /** Add a callback fired after a task activity ends.
 107    * Triggered after the on_this_end function, but before sending tokens to successors.**/
 108   static void on_completion_cb(const std::function<void(Task*)>& cb) { on_completion.connect(cb); }
 109
 110 #ifndef DOXYGEN
 111   friend void intrusive_ptr_release(Task* o)
 112   {
 113     if (o->refcount_.fetch_sub(1, std::memory_order_release) == 1) {
 114       std::atomic_thread_fence(std::memory_order_acquire);
 115       delete o;
 116     }
 117   }
 118   friend void intrusive_ptr_add_ref(Task* o) { o->refcount_.fetch_add(1, std::memory_order_relaxed); }
 119 #endif
 120 };
 121
 122 class CommTask : public Task {
 123   Host* source_;
 124   Host* destination_;
 125
 126   explicit CommTask(const std::string& name);
 127   void fire(std::string instance) override;
 128
 129 public:
 130   static CommTaskPtr init(const std::string& name);
 131   static CommTaskPtr init(const std::string& name, double bytes, Host* source, Host* destination);
 132
 133   CommTaskPtr set_source(Host* source);
 134   Host* get_source() const { return source_; }
 135   CommTaskPtr set_destination(Host* destination);
 136   Host* get_destination() const { return destination_; }
 137   CommTaskPtr set_bytes(double bytes);
 138   double get_bytes() const { return get_amount("instance_0"); }
 139 };
 140
 141 class ExecTask : public Task {
 142   std::map<std::string, Host*> host_ = {{"instance_0", nullptr}, {"dispatcher", nullptr}, {"collector", nullptr}};
 143
 144   explicit ExecTask(const std::string& name);
 145   void fire(std::string instance) override;
 146
 147 public:
 148   static ExecTaskPtr init(const std::string& name);
 149   static ExecTaskPtr init(const std::string& name, double flops, Host* host);
 150
 151   ExecTaskPtr set_host(Host* host, std::string instance = "all");
 152   Host* get_host(std::string instance = "instance_0") const { return host_.at(instance); }
 153   ExecTaskPtr set_flops(double flops, std::string instance = "instance_0");
 154   double get_flops(std::string instance = "instance_0") const { return get_amount(instance); }
 155
 156   void add_instances(int n) override;
 157   void remove_instances(int n) override;
 158 };
 159
 160 class IoTask : public Task {
 161   Disk* disk_;
 162   Io::OpType type_;
 163   explicit IoTask(const std::string& name);
 164   void fire(std::string instance) override;
 165
 166 public:
 167   static IoTaskPtr init(const std::string& name);
 168   static IoTaskPtr init(const std::string& name, double bytes, Disk* disk, Io::OpType type);
 169
 170   IoTaskPtr set_disk(Disk* disk);
 171   Disk* get_disk() const { return disk_; }
 172   IoTaskPtr set_bytes(double bytes);
 173   double get_bytes() const { return get_amount("instance_0"); }
 174   IoTaskPtr set_op_type(Io::OpType type);
 175   Io::OpType get_op_type() const { return type_; }
 176 };
 177 } // namespace simgrid::s4u
 178 #endif