X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/39c935d6d5ee86d153f6f7e6a10d723ae7c57f6f..0f04bc651ecbb1b743345364ee076aa8e68b4f4e:/include/simgrid/s4u/Activity.hpp

diff --git a/include/simgrid/s4u/Activity.hpp b/include/simgrid/s4u/Activity.hpp
index e4fb4c8500..3e31a941ff 100644
--- a/include/simgrid/s4u/Activity.hpp
+++ b/include/simgrid/s4u/Activity.hpp
@@ -6,13 +6,16 @@
 #ifndef SIMGRID_S4U_ACTIVITY_HPP
 #define SIMGRID_S4U_ACTIVITY_HPP
 
-#include "xbt/asserts.h"
+#include <xbt/asserts.h>
+#include <algorithm>
 #include <atomic>
 #include <set>
 #include <simgrid/forward.h>
+#include <stdexcept>
 #include <string>
 #include <vector>
 #include <xbt/signal.hpp>
+#include <xbt/utility.hpp>
 
 XBT_LOG_EXTERNAL_CATEGORY(s4u_activity);
 
@@ -29,10 +32,23 @@ class XBT_PUBLIC Activity {
   friend Exec;
   friend Io;
 
+public:
+  // enum class State { ... }
+  XBT_DECLARE_ENUM_CLASS(State, INITED, STARTING, STARTED, CANCELED, FINISHED);
+
 protected:
   Activity()  = default;
   virtual ~Activity() = default;
 
+  virtual bool is_assigned() const = 0;
+
+  virtual void complete(Activity::State state)
+  {
+    state_ = state;
+    if (state == State::FINISHED)
+      release_dependencies();
+  }
+
   void release_dependencies()
   {
     while (not successors_.empty()) {
@@ -48,16 +64,35 @@ protected:
 
   void add_successor(ActivityPtr a)
   {
+    if(this == a)
+      throw std::invalid_argument("Cannot be its own successor");
+    auto p = std::find_if(successors_.begin(), successors_.end(), [a](ActivityPtr const& i){ return i.get() == a.get(); });
+    if (p != successors_.end())
+      throw std::invalid_argument("Dependency already exists");
+
     successors_.push_back(a);
     a->dependencies_.insert({this});
   }
 
+  void remove_successor(ActivityPtr a)
+  {
+    if(this == a)
+      throw std::invalid_argument("Cannot ask to remove its from successors");
+
+    auto p = std::find_if(successors_.begin(), successors_.end(), [a](ActivityPtr const& i){ return i.get() == a.get(); });
+    if (p != successors_.end()){
+      successors_.erase(p);
+      a->dependencies_.erase({this});
+    } else
+      throw std::invalid_argument("Dependency does not exist. Can not be removed.");
+  }
+
 public:
   void vetoable_start()
   {
     state_ = State::STARTING;
-    if (dependencies_.empty()) {
-      XBT_CVERB(s4u_activity, "All dependencies are solved, let's start '%s'", get_cname());
+    if (dependencies_.empty() && is_assigned()) {
+      XBT_CVERB(s4u_activity, "'%s' is assigned to a resource and all dependencies are solved. Let's start", get_cname());
       start();
     }
   }
@@ -67,26 +102,26 @@ public:
   Activity& operator=(Activity const&) = delete;
 #endif
 
-  enum class State { INITED = 0, STARTING, STARTED, CANCELED, FINISHED };
-
   /** Starts a previously created activity.
    *
    * This function is optional: you can call wait() even if you didn't call start()
    */
   virtual Activity* start() = 0;
   /** Blocks the current actor until the activity is terminated */
-  virtual Activity* wait() = 0;
+  Activity* wait() { return wait_for(-1.0); }
   /** Blocks the current actor until the activity is terminated, or until the timeout is elapsed\n
    *  Raises: timeout exception.*/
-  virtual Activity* wait_for(double timeout) = 0;
+  Activity* wait_for(double timeout);
   /** Blocks the current actor until the activity is terminated, or until the time limit is reached\n
    * Raises: timeout exception. */
   void wait_until(double time_limit);
 
   /** Cancel that activity */
-  virtual Activity* cancel() = 0;
+  Activity* cancel();
   /** Retrieve the current state of the activity */
   Activity::State get_state() const { return state_; }
+  /** Return a string representation of the activity's state (one of INITED, STARTING, STARTED, CANCELED, FINISHED) */
+  const char* get_state_str() const;
   void set_state(Activity::State state) { state_ = state; }
   /** Tests whether the given activity is terminated yet. */
   virtual bool test();
@@ -149,7 +184,11 @@ public:
     Activity::add_successor(a);
     return static_cast<AnyActivity*>(this);
   }
-
+  AnyActivity* remove_successor(ActivityPtr a)
+  {
+    Activity::remove_successor(a);
+    return static_cast<AnyActivity*>(this);
+  }
   AnyActivity* set_name(const std::string& name)
   {
     xbt_assert(get_state() == State::INITED, "Cannot change the name of an activity after its start");
@@ -174,6 +213,17 @@ public:
   }
 
   void* get_user_data() const { return user_data_; }
+
+  AnyActivity* vetoable_start()
+  {
+    Activity::vetoable_start();
+    return static_cast<AnyActivity*>(this);
+  }
+
+  AnyActivity* cancel() { return static_cast<AnyActivity*>(Activity::cancel()); }
+  AnyActivity* wait() { return wait_for(-1.0); }
+  virtual AnyActivity* wait_for(double timeout) { return static_cast<AnyActivity*>(Activity::wait_for(timeout)); }
+
 #ifndef DOXYGEN
   /* The refcounting is done in the ancestor class, Activity, but we want each of the classes benefiting of the CRTP
    * (Exec, Comm, etc) to have smart pointers too, so we define these methods here, that forward the ptr_release and