X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/de74e33ac31948d22f805fed0807be831cb8fdbd..e049fe573b321fbf974191c9f084873dc306009c:/src/surf/surf.hpp?ds=sidebyside

diff --git a/src/surf/surf.hpp b/src/surf/surf.hpp
index 636d6a4327..862173d4cf 100644
--- a/src/surf/surf.hpp
+++ b/src/surf/surf.hpp
@@ -15,15 +15,14 @@
 #include "xbt/lib.h"
 #include "surf/surf_routing.h"
 #include "simgrid/platf_interface.h"
+#include "surf/surf.h"
+#include "surf/surf_private.h"
 
 extern tmgr_history_t history;
 #define NO_MAX_DURATION -1.0
 
 using namespace std;
 
-// TODO: put in surf_private.hpp
-extern xbt_dict_t watched_hosts_lib;
-
 /** \ingroup SURF_simulation
  *  \brief Return the current time
  *
@@ -34,6 +33,19 @@ extern xbt_dict_t watched_hosts_lib;
  * Utils *
  *********/
 
+/* user-visible parameters */
+extern double sg_tcp_gamma;
+extern double sg_sender_gap;
+extern double sg_latency_factor;
+extern double sg_bandwidth_factor;
+extern double sg_weight_S_parameter;
+extern int sg_network_crosstraffic;
+#ifdef HAVE_GTNETS
+extern double sg_gtnets_jitter;
+extern int sg_gtnets_jitter_seed;
+#endif
+extern xbt_dynar_t surf_path;
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -43,22 +55,35 @@ XBT_PUBLIC(void) surf_watched_hosts(void);
 }
 #endif
 
+extern double sg_sender_gap;
 XBT_PUBLIC(int)  SURF_CPU_LEVEL;    //Surf cpu level
 
+int __surf_is_absolute_file_path(const char *file_path);
+
 /***********
  * Classes *
  ***********/
-class Model;
+//class Model;
 typedef Model* ModelPtr;
 
-class Resource;
+//class Resource;
 typedef Resource* ResourcePtr;
 typedef boost::function<void (ResourcePtr r)> ResourceCallback;
 			
-class Action;
+//class Action;
 typedef Action* ActionPtr;
 typedef boost::function<void (ActionPtr a)> ActionCallback;
 
+//class ActionLmm;
+typedef ActionLmm* ActionLmmPtr;
+
+enum heap_action_type{
+  LATENCY = 100,
+  MAX_DURATION,
+  NORMAL,
+  NOTSET
+};
+
 /*********
  * Trace *
  *********/
@@ -78,21 +103,20 @@ XBT_PUBLIC_DATA(xbt_dynar_t) model_list;
 
 class Model {
 public:
-  Model(string name) {
-    m_name = name;
-    m_resOnCB = m_resOffCB= 0;
-    m_actSuspendCB = m_actCancelCB = m_actResumeCB = 0;
-  }
-  virtual ~Model() {
-    xbt_swag_free(p_readyActionSet);
-    xbt_swag_free(p_runningActionSet);
-    xbt_swag_free(p_failedActionSet);
-    xbt_swag_free(p_doneActionSet);
-  }
+  Model(string name);
+  virtual ~Model();
+
   ResourcePtr createResource(string name);
   ActionPtr createAction(double _cost, bool _failed);
-  double shareResources(double now);
-  void updateActionsState(double now, double delta);
+  virtual double shareResources(double now);
+  virtual double shareResourcesLazy(double now);
+  virtual double shareResourcesFull(double now);
+  double shareResourcesMaxMin(xbt_swag_t running_actions,
+                                      lmm_system_t sys,
+                                      void (*solve) (lmm_system_t));
+  virtual void updateActionsState(double now, double delta);
+  virtual void updateActionsStateLazy(double now, double delta);
+  virtual void updateActionsStateFull(double now, double delta);
 
   string getName() {return m_name;};
 
@@ -109,16 +133,22 @@ public:
   void addActionSuspendCallback(ActionCallback ac);  
   void notifyActionSuspend(ActionPtr a);
 
+  lmm_system_t p_maxminSystem;
+  e_UM_t p_updateMechanism;
+  xbt_swag_t p_modifiedSet;
+  xbt_heap_t p_actionHeap;
+  int m_selectiveUpdate;
+
   xbt_swag_t p_readyActionSet; /**< Actions in state SURF_ACTION_READY */
   xbt_swag_t p_runningActionSet; /**< Actions in state SURF_ACTION_RUNNING */
   xbt_swag_t p_failedActionSet; /**< Actions in state SURF_ACTION_FAILED */
   xbt_swag_t p_doneActionSet; /**< Actions in state SURF_ACTION_DONE */
+  string m_name;
 
 protected:
   std::vector<ActionPtr> m_failedActions, m_runningActions;
 
 private:
-  string m_name;
   ResourceCallback m_resOnCB, m_resOffCB;
   ActionCallback m_actCancelCB, m_actSuspendCB, m_actResumeCB;
 };
@@ -126,127 +156,108 @@ private:
 /************
  * Resource *
  ************/
+
+/**
+ * Resource which have a metric handled by a maxmin system
+ */
+typedef struct {
+  double scale;
+  double peak;
+  tmgr_trace_event_t event;
+} s_surf_metric_t;
+
 class Resource {
 public:
-  Resource(ModelPtr model, const char *name, xbt_dict_t properties):
-	  m_name(name),m_running(true),p_model(model),m_properties(properties) {};
+  Resource();
+  Resource(ModelPtr model, const char *name, xbt_dict_t properties);
   virtual ~Resource() {};
 
-  void updateState(tmgr_trace_event_t event_type, double value, double date);
+  virtual void updateState(tmgr_trace_event_t event_type, double value, double date)=0;
 
   //private
-  bool isUsed();
-  //TODOupdateActionState();
-  //TODOupdateResourceState();
-  //TODOfinilize();
+  virtual bool isUsed()=0;
+  //FIXME:updateActionState();
+  //FIXME:updateResourceState();
+  //FIXME:finilize();
 
   bool isOn();
   void turnOn();
   void turnOff();
   void setName(string name);
-  string getName();
+  const char *getName();
+  virtual xbt_dict_t getProperties();
+
   ModelPtr getModel() {return p_model;};
+  virtual e_surf_resource_state_t getState();
   void printModel() { std::cout << p_model->getName() << "<<plop"<<std::endl;};
   void *p_resource;
-  e_surf_resource_state_t m_stateCurrent;
-
-protected:
-  ModelPtr p_model;
   const char *m_name;
   xbt_dict_t m_properties;
+  ModelPtr p_model;
+  e_surf_resource_state_t p_stateCurrent;
+
+protected:
 
 private:
   bool m_running;  
 };
 
-static inline void *surf_cpu_resource_priv(const void *host) {
-  return xbt_lib_get_level((xbt_dictelm_t)host, SURF_CPU_LEVEL);
-}
-/*static inline void *surf_workstation_resource_priv(const void *host){
-  return xbt_lib_get_level((xbt_dictelm_t)host, SURF_WKS_LEVEL); 
-}        
-static inline void *surf_storage_resource_priv(const void *host){
-  return xbt_lib_get_level((xbt_dictelm_t)host, SURF_STORAGE_LEVEL);
-}*/
-
-static inline void *surf_cpu_resource_by_name(const char *name) {
-  return xbt_lib_get_elm_or_null(host_lib, name);
-}
-/*static inline void *surf_workstation_resource_by_name(const char *name){
-  return xbt_lib_get_elm_or_null(host_lib, name);
-}
-static inline void *surf_storage_resource_by_name(const char *name){
-  return xbt_lib_get_elm_or_null(storage_lib, name);*/
+class ResourceLmm: virtual public Resource {
+public:
+  ResourceLmm() {};
+  ResourceLmm(surf_model_t model, const char *name, xbt_dict_t props,
+                           lmm_system_t system,
+                           double constraint_value,
+                           tmgr_history_t history,
+                           e_surf_resource_state_t state_init,
+                           tmgr_trace_t state_trace,
+                           double metric_peak,
+                           tmgr_trace_t metric_trace);
+  lmm_constraint_t p_constraint;
+  tmgr_trace_event_t p_stateEvent;
+  s_surf_metric_t p_power;
+};
 
 /**********
  * Action *
  **********/
 
-/** \ingroup SURF_actions
- *  \brief Action states
- *
- *  Action states.
- *
- *  \see surf_action_t, surf_action_state_t
- */
-extern const char *surf_action_state_names[6];
-
-typedef enum {
-  SURF_ACTION_READY = 0,        /**< Ready        */
-  SURF_ACTION_RUNNING,          /**< Running      */
-  SURF_ACTION_FAILED,           /**< Task Failure */
-  SURF_ACTION_DONE,             /**< Completed    */
-  SURF_ACTION_TO_FREE,          /**< Action to free in next cleanup */
-  SURF_ACTION_NOT_IN_THE_SYSTEM
-                                /**< Not in the system anymore. Why did you ask ? */
-} e_surf_action_state_t;
-
-typedef enum {
-  UM_FULL,
-  UM_LAZY,
-  UM_UNDEFINED
-} e_UM_t;
-
 class Action {
 public:
-  Action(ModelPtr model, double cost, bool failed):
-	 m_cost(cost), p_model(model), m_failed(failed),
-	 m_refcount(1), m_priority(1.0), m_maxDuration(NO_MAX_DURATION),
-	 m_start(surf_get_clock()), m_finish(-1.0)
-  {
-    m_priority = m_start = m_finish = m_maxDuration = -1.0;
-    m_start = 10;//surf_get_clock();
-    m_suspended = false;
-  };
-  virtual ~Action() {};
+  Action();
+  Action(ModelPtr model, double cost, bool failed);
+  virtual ~Action();
   
+  s_xbt_swag_hookup_t p_stateHookup;
+
   e_surf_action_state_t getState(); /**< get the state*/
-  void setState(e_surf_action_state_t state); /**< Change state*/
+  virtual void setState(e_surf_action_state_t state); /**< Change state*/
   double getStartTime(); /**< Return the start time of an action */
   double getFinishTime(); /**< Return the finish time of an action */
   void setData(void* data);
 
-  virtual int unref()=0;     /**< Specify that we don't use that action anymore. Returns true if the action was destroyed and false if someone still has references on it. */
-  virtual void cancel()=0;     /**< Cancel a running action */
-  virtual void recycle()=0;     /**< Recycle an action */
+  void ref();
+  virtual int unref();     /**< Specify that we don't use that action anymore. Returns true if the action was destroyed and false if someone still has references on it. */
+  virtual void cancel();     /**< Cancel a running action */
+  virtual void recycle();     /**< Recycle an action */
   
-  void suspend();     /**< Suspend an action */
-  void resume();     /**< Resume a suspended action */
-  bool isSuspended();     /**< Return whether an action is suspended */
-  void setMaxDuration(double duration);     /**< Set the max duration of an action*/
-  void setPriority(double priority);     /**< Set the priority of an action */
+  virtual void suspend()=0;     /**< Suspend an action */
+  virtual void resume()=0;     /**< Resume a suspended action */
+  virtual bool isSuspended()=0;     /**< Return whether an action is suspended */
+  virtual void setMaxDuration(double duration)=0;     /**< Set the max duration of an action*/
+  virtual void setPriority(double priority)=0;     /**< Set the priority of an action */
 #ifdef HAVE_TRACING
   void setCategory(const char *category); /**< Set the category of an action */
 #endif
-  double getRemains();     /**< Get the remains of an action */
+  virtual double getRemains();     /**< Get the remains of an action */
 #ifdef HAVE_LATENCY_BOUND_TRACKING
   int getLatencyLimited();     /**< Return 1 if action is limited by latency, 0 otherwise */
 #endif
+
   xbt_swag_t p_stateSet;
 
   double m_priority; /**< priority (1.0 by default) */
   bool m_failed;
-  bool m_suspended;  
   double m_start; /**< start time  */
   double m_finish; /**< finish time : this is modified during the run and fluctuates until the task is completed */
   double m_remains; /**< How much of that cost remains to be done in the currently running task */
@@ -254,14 +265,15 @@ public:
   int m_latencyLimited;               /**< Set to 1 if is limited by latency, 0 otherwise */
   #endif
   double m_maxDuration; /*< max_duration (may fluctuate until the task is completed) */  
+  char *p_category;               /**< tracing category for categorized resource utilization monitoring */  
+  int    m_cost;
+  void *p_data; /**< for your convenience */
 protected:
   ModelPtr p_model;  
-  int    m_cost;
   int    m_refcount;
-  void *p_data; /**< for your convenience */
 #ifdef HAVE_TRACING
-  char *p_category;               /**< tracing category for categorized resource utilization monitoring */
 #endif
+  e_UM_t p_updateMechanism;
 
 private:
   int resourceUsed(void *resource_id);
@@ -272,13 +284,48 @@ private:
   void updateActionsState(double now, double delta);
   void updateResourceState(void *id, tmgr_trace_event_t event_type,
                                  double value, double time);
-  void finalize(void);
 
-  lmm_system_t p_maxminSystem;
-  e_UM_t p_updateMechanism;
   xbt_swag_t p_modifiedSet;
   xbt_heap_t p_actionHeap;
   int m_selectiveUpdate;
 };
 
+//FIXME:REMOVE
+void surf_action_lmm_update_index_heap(void *action, int i);
+
+class ActionLmm: virtual public Action {
+public:
+  ActionLmm() : m_suspended(false) {
+	p_actionListHookup.prev = 0;
+	p_actionListHookup.next = 0;
+  };
+  ActionLmm(ModelPtr model, double cost, bool failed) : m_suspended(false) {
+	p_actionListHookup.prev = 0;
+	p_actionListHookup.next = 0;
+  };
+
+  virtual void updateRemainingLazy(double now);
+  void heapInsert(xbt_heap_t heap, double key, enum heap_action_type hat);
+  void heapRemove(xbt_heap_t heap);
+  double getRemains();     /**< Get the remains of an action */
+  void updateIndexHeap(int i);
+
+  virtual int unref();
+  void cancel();
+  void suspend();
+  void resume();
+  bool isSuspended();
+  void setMaxDuration(double duration);
+  void setPriority(double priority);
+  void gapRemove();
+
+  lmm_variable_t p_variable;
+  s_xbt_swag_hookup_t p_actionListHookup;
+  int m_indexHeap;
+  double m_lastUpdate;
+  double m_lastValue;
+  enum heap_action_type m_hat;
+  int m_suspended;
+};
+
 #endif /* SURF_MODEL_H_ */