X-Git-Url: http://bilbo.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/b9ee19619702cc8328ea6127b880cf1d86465953..68701a14f6323155ceb9a0af8e82679cd10fe8ae:/include/simgrid/plugins/operation.hpp

diff --git a/include/simgrid/plugins/operation.hpp b/include/simgrid/plugins/operation.hpp
index acd7dddba1..7dbbb337c1 100644
--- a/include/simgrid/plugins/operation.hpp
+++ b/include/simgrid/plugins/operation.hpp
@@ -4,6 +4,7 @@
 #include <simgrid/s4u/Activity.hpp>
 #include <xbt/Extendable.hpp>
 
+#include <atomic>
 #include <map>
 #include <memory>
 #include <set>
@@ -11,18 +12,21 @@
 namespace simgrid::plugins {
 
 class Operation;
-using OperationPtr = std::shared_ptr<Operation>;
+using OperationPtr = boost::intrusive_ptr<Operation>;
+XBT_PUBLIC void intrusive_ptr_release(Operation* o);
+XBT_PUBLIC void intrusive_ptr_add_ref(Operation* o);
 class ExecOp;
-using ExecOpPtr = std::shared_ptr<ExecOp>;
+using ExecOpPtr = boost::intrusive_ptr<ExecOp>;
+XBT_PUBLIC void intrusive_ptr_release(ExecOp* e);
+XBT_PUBLIC void intrusive_ptr_add_ref(ExecOp* e);
 class CommOp;
-using CommOpPtr = std::shared_ptr<CommOp>;
+using CommOpPtr =  boost::intrusive_ptr<CommOp>;
+XBT_PUBLIC void intrusive_ptr_release(CommOp* c);
+XBT_PUBLIC void intrusive_ptr_add_ref(CommOp* c);
 
-class ExtendedAttributeActivity {
-public:
+struct ExtendedAttributeActivity {
   static simgrid::xbt::Extension<simgrid::s4u::Activity, ExtendedAttributeActivity> EXTENSION_ID;
   Operation* operation_;
-
-  ExtendedAttributeActivity(){};
 };
 
 class Operation {
@@ -43,26 +47,31 @@ protected:
   int queued_execs_ = 0;
   int count_        = 0;
   bool working_     = false;
-  simgrid::s4u::ActivityPtr current_activity_;
-  std::function<void(Operation*)> end_func_   = [](Operation*) {};
-  std::function<void(Operation*)> start_func_ = [](Operation*) {};
-  Operation(const std::string& name);
+  s4u::ActivityPtr current_activity_;
+  std::function<void(Operation*)> end_func_;
+  std::function<void(Operation*)> start_func_;
+  explicit Operation(const std::string& name);
   virtual ~Operation()   = default;
   virtual void execute() = 0;
 
   static xbt::signal<void(Operation*)> on_start;
   static xbt::signal<void(Operation*)> on_end;
+  std::atomic_int_fast32_t refcount_{0};
 
 public:
   static void init();
-  std::string get_name();
+  const std::string& get_name() const { return name_; }
+  const char* get_cname() const { return name_.c_str(); }
   void enqueue_execs(int n);
   void set_amount(double amount);
+  double get_amount() const { return amount_; }
   void add_successor(OperationPtr op);
   void remove_successor(OperationPtr op);
-  void on_this_start(std::function<void(Operation*)> func);
-  void on_this_end(std::function<void(Operation*)> func);
-  int get_count();
+  void remove_all_successors();
+  const std::set<Operation*>& get_successors() const { return successors_ ;}
+  void on_this_start(const std::function<void(Operation*)>& func);
+  void on_this_end(const std::function<void(Operation*)>& func);
+  int get_count() const;
 
   /** Add a callback fired before an operation activity start.
    * Triggered after the on_this_start function**/
@@ -71,37 +80,58 @@ public:
    * Triggered after the on_this_end function, but before
    * sending tokens to successors.**/
   static void on_end_cb(const std::function<void(Operation*)>& cb) { on_end.connect(cb); }
+
+#ifndef DOXYGEN
+  friend void intrusive_ptr_release(Operation* o)
+  {
+    if (o->refcount_.fetch_sub(1, std::memory_order_release) == 1) {
+      std::atomic_thread_fence(std::memory_order_acquire);
+      delete o;
+    }
+  }
+  friend void intrusive_ptr_add_ref(Operation* o) { o->refcount_.fetch_add(1, std::memory_order_relaxed); }
+#endif
 };
 
 class ExecOp : public Operation {
 private:
-  simgrid::s4u::Host* host_;
+  s4u::Host* host_;
 
-  ExecOp(const std::string& name);
+  explicit ExecOp(const std::string& name);
   void execute() override;
 
 public:
   static ExecOpPtr init(const std::string& name);
-  static ExecOpPtr init(const std::string& name, double flops, simgrid::s4u::Host* host);
-  void set_host(simgrid::s4u::Host* host);
-  void set_flops(double flops);
+  static ExecOpPtr init(const std::string& name, double flops, s4u::Host* host);
+  ExecOpPtr set_host(s4u::Host* host);
+  s4u::Host* get_host() const { return host_; }
+  ExecOpPtr set_flops(double flops);
+  double get_flops() const { return get_amount(); }
+  friend void inline intrusive_ptr_release(ExecOp* e) { intrusive_ptr_release(static_cast<Operation*>(e)); }
+  friend void inline intrusive_ptr_add_ref(ExecOp* e) { intrusive_ptr_add_ref(static_cast<Operation*>(e)); }
 };
 
 class CommOp : public Operation {
 private:
-  simgrid::s4u::Host* source_;
-  simgrid::s4u::Host* destination_;
+  s4u::Host* source_;
+  s4u::Host* destination_;
 
-  CommOp(const std::string& name);
+  explicit CommOp(const std::string& name);
   void execute() override;
 
 public:
   static CommOpPtr init(const std::string& name);
-  static CommOpPtr init(const std::string& name, double bytes, simgrid::s4u::Host* source,
-                        simgrid::s4u::Host* destination);
-  void set_source(simgrid::s4u::Host* source);
-  void set_destination(simgrid::s4u::Host* destination);
-  void set_bytes(double bytes);
+  static CommOpPtr init(const std::string& name, double bytes, s4u::Host* source,
+                        s4u::Host* destination);
+  CommOpPtr set_source(s4u::Host* source);
+  s4u::Host* get_source() const { return source_; }
+  CommOpPtr set_destination(s4u::Host* destination);
+  s4u::Host* get_destination() const { return destination_; }
+  CommOpPtr set_bytes(double bytes);
+  double get_bytes() const { return get_amount(); }
+   friend void inline intrusive_ptr_release(CommOp* c) { intrusive_ptr_release(static_cast<Operation*>(c)); }
+  friend void inline intrusive_ptr_add_ref(CommOp* c) { intrusive_ptr_add_ref(static_cast<Operation*>(c)); }
+
 };
 } // namespace simgrid::plugins
 #endif