X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/936a14d7a4de6b0ab971a416d16a2b7099fc5cc1..12c0f182635ed71b370d608b5b9a614153765cd4:/src/include/surf/surf.h

diff --git a/src/include/surf/surf.h b/src/include/surf/surf.h
index 3b684fed50..cb867e323b 100644
--- a/src/include/surf/surf.h
+++ b/src/include/surf/surf.h
@@ -79,6 +79,13 @@ enum heap_action_type{
   NOTSET
 };
 
+
+typedef struct surf_resource {
+  surf_model_t model;
+  char *name;
+  xbt_dict_t properties;
+} s_surf_resource_t, *surf_resource_t;
+
 /** \ingroup SURF_actions
  *  \brief Action structure
  *
@@ -92,6 +99,7 @@ typedef struct surf_action {
   xbt_swag_t state_set;
   double cost;                  /**< cost        */
   double priority;              /**< priority (1.0 by default) */
+  double bound;              /**< the capping of the CPU use  */
   double max_duration;          /**< max_duration (may fluctuate until
            the task is completed) */
   double remains;               /**< How much of that cost remains to
@@ -105,7 +113,12 @@ typedef struct surf_action {
          * and fluctuates until the task is completed */
   void *data;                   /**< for your convenience */
   int refcount;
-  surf_model_t model_type;
+
+  /* The previous name was model_type. For VM support, we have to distinguish a
+   * model type and its model object. Thus, we use model_obj here. The type of
+   * a model object is available by looking at the inside of the model object. */
+  surf_model_t model_obj;       /**< the surf model object */
+
 #ifdef HAVE_TRACING
   char *category;               /**< tracing category for categorized resource utilization monitoring */
 #endif
@@ -193,6 +206,8 @@ typedef struct surf_cpu_model_extension_public {
   surf_action_t(*execute) (void *cpu, double size);
   surf_action_t(*sleep) (void *cpu, double duration);
   e_surf_resource_state_t(*get_state) (void *cpu);
+  void(*set_state) (void *cpu, e_surf_resource_state_t state);
+
   int (*get_core) (void *cpu);
   double (*get_speed) (void *cpu, double load);
   double (*get_available_speed) (void *cpu);
@@ -236,16 +251,20 @@ typedef struct surf_storage_model_extension_public {
   surf_action_t(*ls) (void *storage, const char *path);
 } s_surf_model_extension_storage_t;
 
-     /** \ingroup SURF_models
-      *  \brief Workstation model extension public
-      *
-      *  Public functions specific to the workstation model.
-      */
+/** \ingroup SURF_models
+ *  \brief Workstation model extension public
+ *
+ *  Public functions specific to the workstation model.
+ */
 typedef struct surf_workstation_model_extension_public {
+  /* This points to the surf cpu model object bound to the workstation model. */
+  surf_model_t cpu_model;
+
   surf_action_t(*execute) (void *workstation, double size);                                /**< Execute a computation amount on a workstation
                                       and create the corresponding action */
   surf_action_t(*sleep) (void *workstation, double duration);                              /**< Make a workstation sleep during a given duration */
   e_surf_resource_state_t(*get_state) (void *workstation);                                      /**< Return the CPU state of a workstation */
+  void(*set_state) (void *workstation, e_surf_resource_state_t state);
   int (*get_core) (void *workstation); 
   double (*get_speed) (void *workstation, double load);                                    /**< Return the speed of a workstation */
   double (*get_available_speed) (void *workstation);                                       /**< Return tha available speed of a workstation */
@@ -278,10 +297,60 @@ typedef struct surf_workstation_model_extension_public {
    xbt_dict_t(*get_properties) (const void *resource);
   void (*add_traces) (void);
 
+  void (*get_params) (void *ind_vm_ws, ws_params_t param);
+  void (*set_params) (void *ind_vm_ws, ws_params_t param);
+  xbt_dynar_t (*get_vms) (void *ind_vm_ws);
+
 } s_surf_model_extension_workstation_t;
 
+typedef struct surf_vm_workstation_model_extension_public {
+  /* The vm workstation model object has all members of the physical machine
+   * workstation model object. If these members are correctly initialized also
+   * in the vm workstation model object, we can access the vm workstation model
+   * object as if it is the pm workstatoin model object.
+   *
+   * But, it's not so clean. Think it again later.
+   * */
+  s_surf_model_extension_workstation_t basic;
+
+  // start does not appear here as it corresponds to turn the state from created to running (see smx_vm.c)
+
+  void   (*create)  (const char *name, void *ind_phys_workstation); // First operation of the VM model
+  void   (*destroy) (void *ind_vm_ws); // will be vm_ws_destroy(), which destroies the vm-workstation-specific data
+
+  void   (*suspend) (void *ind_vm_ws);
+  void   (*resume)  (void *ind_vm_ws);
+
+  void   (*save)    (void *ind_vm_ws);
+  void   (*restore) (void *ind_vm_ws);
+
+  void   (*migrate) (void *ind_vm_ws, void *ind_vm_ws_dest); // will be vm_ws_migrate()
+
+  int    (*get_state) (void *ind_vm_ws);
+  void   (*set_state) (void *ind_vm_ws, int state);
+
+  void * (*get_pm) (void *ind_vm_ws); // will be vm_ws_get_pm()
 
+  void   (*set_vm_bound) (void *ind_vm_ws, double bound); // will be vm_ws_set_vm_bound()
 
+} s_surf_model_extension_vm_workstation_t;
+
+/** \ingroup SURF_models
+ *  \brief Model types
+ *
+ *  The type of the model object. For example, we will have two model objects
+ *  of the surf cpu model. One is for physical machines, and the other is for
+ *  virtual machines.
+ *
+ */
+typedef enum {
+  SURF_MODEL_TYPE_CPU = 0,
+  SURF_MODEL_TYPE_NETWORK,
+  SURF_MODEL_TYPE_STORAGE,
+  SURF_MODEL_TYPE_WORKSTATION,
+  SURF_MODEL_TYPE_VM_WORKSTATION,
+  SURF_MODEL_TYPE_NEW_MODEL
+} e_surf_model_type_t;
 
 /** \ingroup SURF_models
  *  \brief Model datatype
@@ -293,7 +362,9 @@ typedef struct surf_model {
   const char *name;     /**< Name of this model */
   s_surf_action_state_t states;      /**< Any living action on this model */
 
-   e_surf_action_state_t(*action_state_get) (surf_action_t action);
+  e_surf_model_type_t type; /**< See e_surf_model_type_t */
+
+  e_surf_action_state_t(*action_state_get) (surf_action_t action);
                                                                        /**< Return the state of an action */
   void (*action_state_set) (surf_action_t action,
                             e_surf_action_state_t state);
@@ -310,6 +381,7 @@ typedef struct surf_model {
   int (*is_suspended) (surf_action_t action);     /**< Return whether an action is suspended */
   void (*set_max_duration) (surf_action_t action, double duration);     /**< Set the max duration of an action*/
   void (*set_priority) (surf_action_t action, double priority);     /**< Set the priority of an action */
+  void (*set_bound) (surf_action_t action, double bound);     /**< Set the bound (the maximum CPU utilization) of an action */
 #ifdef HAVE_TRACING
   void (*set_category) (surf_action_t action, const char *category); /**< Set the category of an action */
 #endif
@@ -327,6 +399,8 @@ typedef struct surf_model {
     s_surf_model_extension_network_t network;
     s_surf_model_extension_storage_t storage;
     s_surf_model_extension_workstation_t workstation;
+    // TODO Implement the corresponding model
+    s_surf_model_extension_vm_workstation_t vm_workstation;
     /*******************************************/
     /* TUTORIAL: New model                     */
     s_surf_model_extension_new_model_t new_model;
@@ -357,11 +431,14 @@ static inline void *surf_storage_resource_by_name(const char *name){
   return xbt_lib_get_elm_or_null(storage_lib, name);
 }
 
-typedef struct surf_resource {
-  surf_model_t model;
-  char *name;
-  xbt_dict_t properties;
-} s_surf_resource_t, *surf_resource_t;
+static inline surf_model_t surf_resource_model(const void *host, int level) {
+  /* If level is SURF_WKS_LEVEL, ws is a workstation_CLM03 object. It has
+   * surf_resource at the generic_resource field. */
+  surf_resource_t ws = xbt_lib_get_level((void *) host, level);
+  return ws->model;
+}
+
+
 
 /**
  * Resource which have a metric handled by a maxmin system
@@ -386,9 +463,14 @@ typedef struct surf_resource_lmm {
 
 
 /** \ingroup SURF_models
- *  \brief The CPU model
+ *  \brief The CPU model object for the physical machine layer
+ */
+XBT_PUBLIC_DATA(surf_model_t) surf_cpu_model_pm;
+
+/** \ingroup SURF_models
+ *  \brief The CPU model object for the virtual machine layer
  */
-XBT_PUBLIC_DATA(surf_model_t) surf_cpu_model;
+XBT_PUBLIC_DATA(surf_model_t) surf_cpu_model_vm;
 
 /** \ingroup SURF_models
  *  \brief Initializes the CPU model with the model Cas01
@@ -407,7 +489,7 @@ XBT_PUBLIC(void) surf_cpu_model_init_Cas01(void);
  *
  *  You shouldn't have to call it by yourself.
  */
-XBT_PUBLIC(void) surf_cpu_model_init_ti(void);
+XBT_PUBLIC(surf_model_t) surf_cpu_model_init_ti(void);
 
 /** \ingroup SURF_models
  *  \brief The list of all available optimization modes (both for cpu and networks).
@@ -579,6 +661,16 @@ XBT_PUBLIC_DATA(s_surf_model_description_t) surf_storage_model_description[];
  */
 XBT_PUBLIC_DATA(surf_model_t) surf_workstation_model;
 
+/** \ingroup SURF_models
+ *  \brief The vm_workstation model
+ *
+ *  Note that when you create an API on top of SURF,
+ *  the vm_workstation model should be the only one you use
+ *  because depending on the platform model, the network model and the CPU model
+ *  may not exist.
+ */
+XBT_PUBLIC_DATA(surf_model_t) surf_vm_workstation_model;
+
 /** \ingroup SURF_models
  *  \brief Initializes the platform with a compound workstation model
  *
@@ -627,6 +719,7 @@ XBT_PUBLIC_DATA(s_surf_model_description_t) surf_new_model_description[];
  *  \brief List of initialized models
  */
 XBT_PUBLIC_DATA(xbt_dynar_t) model_list;
+XBT_PUBLIC_DATA(xbt_dynar_t) model_list_invoke;
 
 /*******************************************/
 /*** SURF Platform *************************/