X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/13025e8ea0f4fccfb16bc3214ed42aefa1b8d9d9..98c0dbd4424a6a8177167b573791d25dd01b447d:/src/include/surf/surf.h

diff --git a/src/include/surf/surf.h b/src/include/surf/surf.h
index 6627be748d..aff8a88f87 100644
--- a/src/include/surf/surf.h
+++ b/src/include/surf/surf.h
@@ -28,8 +28,8 @@ typedef enum {
   SURF_NETWORK_ELEMENT_AS,      /* AS type */
 } e_surf_network_element_type_t;
 
-XBT_PUBLIC(e_surf_network_element_type_t) get_network_element_type(const char
-                                                              *name);
+XBT_PUBLIC(e_surf_network_element_type_t)
+  routing_get_network_element_type(const char *name);
 
 /** @Brief Specify that we use that action */
 XBT_PUBLIC(void) surf_action_ref(surf_action_t action);
@@ -48,7 +48,7 @@ XBT_PUBLIC(void *) surf_action_new(size_t size, double cost,
 typedef struct surf_model_description {
   const char *name;
   const char *description;
-  void (*model_init_preparse) (void);
+  void_f_void_t model_init_preparse;
 } s_surf_model_description_t, *surf_model_description_t;
 
 XBT_PUBLIC(int) find_model_description(s_surf_model_description_t * table,
@@ -176,7 +176,7 @@ typedef struct surf_network_model_extension_public {
   surf_action_t(*communicate) (const char *src_name,
                                const char *dst_name,
                                double size, double rate);
-  xbt_dynar_t(*get_route) (const char *src_name, const char *dst_name);
+  xbt_dynar_t(*get_route) (const char *src_name, const char *dst_name); //FIXME: kill field? That is done by the routing nowadays
   double (*get_link_bandwidth) (const void *link);
   double (*get_link_latency) (const void *link);
   int (*link_shared) (const void *link);
@@ -193,6 +193,28 @@ typedef struct surf_network_model_extension_public {
                            xbt_dict_t properties);
 } s_surf_model_extension_network_t;
 
+typedef struct s_surf_file {
+  char *name;                   /**< @brief host name if any */
+  void *data;                   /**< @brief user data */
+} s_surf_file_t;
+typedef struct s_surf_file *surf_file_t;
+
+/* Storage model */
+
+/** \brief Storage model extension public
+ *  \ingroup SURF_models
+ *
+ *  Public functions specific to the Storage model.
+ */
+typedef struct surf_storage_model_extension_public {
+  surf_action_t(*open) (void *workstation, const char* path, const char* mode);
+  surf_action_t(*close) (void *workstation, surf_file_t fp);
+  surf_action_t(*read) (void *workstation, void* ptr, size_t size, size_t nmemb, surf_file_t stream);
+  surf_action_t(*write) (void *workstation, const void* ptr, size_t size, size_t nmemb, surf_file_t stream);
+  surf_action_t(*stat) (void *workstation, int fd, void* buf);
+void* (*create_resource) (const char *name);
+} s_surf_model_extension_storage_t;
+
      /** \brief Workstation model extension public
       *  \ingroup SURF_models
       *
@@ -208,6 +230,7 @@ typedef struct surf_workstation_model_extension_public {
    surf_action_t(*communicate) (void *workstation_src,                                     /**< Execute a communication amount between two workstations */
                                 void *workstation_dst, double size,
                                 double max_rate);
+   // FIXME: kill next field, which duplicates the routing
    xbt_dynar_t(*get_route) (void *workstation_src, void *workstation_dst);                 /**< Get the list of links between two ws */
 
    surf_action_t(*execute_parallel_task) (int workstation_nb,                              /**< Execute a parallel task on several workstations */
@@ -217,6 +240,11 @@ typedef struct surf_workstation_model_extension_public {
                                           double amount, double rate);
   double (*get_link_bandwidth) (const void *link);                                         /**< Return the current bandwidth of a network link */
   double (*get_link_latency) (const void *link);                                           /**< Return the current latency of a network link */
+  surf_action_t(*open) (void *workstation, const char* path, const char* mode);
+  surf_action_t(*close) (void *workstation, surf_file_t fp);
+  surf_action_t(*read) (void *workstation, void* ptr, size_t size, size_t nmemb, surf_file_t stream);
+  surf_action_t(*write) (void *workstation, const void* ptr, size_t size, size_t nmemb, surf_file_t stream);
+  surf_action_t(*stat) (void *workstation, int fd, void* buf);
   int (*link_shared) (const void *link);
    xbt_dict_t(*get_properties) (const void *resource);
   void* (*link_create_resource) (const char *name,
@@ -282,6 +310,7 @@ typedef struct surf_model {
   union extension {
     s_surf_model_extension_cpu_t cpu;
     s_surf_model_extension_network_t network;
+    s_surf_model_extension_storage_t storage;
     s_surf_model_extension_workstation_t workstation;
   } extension;
 } s_surf_model_t;
@@ -337,6 +366,11 @@ XBT_PUBLIC_DATA(surf_model_t) surf_cpu_model;
 /** \brief Initializes the CPU model with the model Cas01
  *  \ingroup SURF_models
  *
+ *  By default, this model uses the lazy optimization mechanism that
+ *  relies on partial invalidation in LMM and a heap for lazy action update.
+ *  You can change this behavior by setting the cpu/optim configuration
+ *  variable to a different value.
+ *
  *  This function is called by surf_workstation_model_init_CLM03
  *  so you shouldn't have to call it by yourself.
  *
@@ -344,21 +378,29 @@ XBT_PUBLIC_DATA(surf_model_t) surf_cpu_model;
  */
 XBT_PUBLIC(void) surf_cpu_model_init_Cas01(void);
 
-/** \brief Initializes the CPU model with trace integration
+/** \brief Initializes the CPU model with trace integration [Deprecated]
  *  \ingroup SURF_models
  *
+ *  You shouldn't have to call it by yourself.
+ *  \see surf_workstation_model_init_CLM03()
  */
 XBT_PUBLIC(void) surf_cpu_model_init_ti(void);
 
-/** \brief Initializes the CPU model with the model Cas01 Improved. This model uses a heap to order the events, decreasing the time complexity to get the minimum next event.
- *  \ingroup SURF_models
+/** \brief This function call the share resources function needed
  *
- *  This function is called by surf_workstation_model_init_CLM03
- *  so you shouldn't have to call it by yourself.
+ */
+XBT_PUBLIC(double) generic_share_resources(double now);
+
+/** \brief This function call the update action state function needed
  *
- *  \see surf_workstation_model_init_CLM03()
  */
-XBT_PUBLIC(void) surf_cpu_model_init_Cas01_im(void);
+XBT_PUBLIC(void)   generic_update_actions_state(double now, double delta);
+
+/** \brief The list of all available optimization modes (both for cpu and networks).
+ *  \ingroup SURF_models
+ *  These optimization modes can be set using --cfg=cpu/optim:... and --cfg=network/optim:...
+ */
+XBT_PUBLIC_DATA(s_surf_model_description_t) surf_optimization_mode_description[];
 
 /** \brief The list of all available cpu model models
  *  \ingroup SURF_models
@@ -384,45 +426,29 @@ XBT_PUBLIC_DATA(surf_model_t) surf_network_model;
 
 /** \brief Same as network model 'LagrangeVelho', only with different correction factors.
  *  \ingroup SURF_models
- *  \param filename XML platform file name
  *
  * This model is proposed by Pierre-Nicolas Clauss and Martin Quinson and Stéphane Génaud
  * based on the model 'LV08' and different correction factors depending on the communication
  * size (< 1KiB, < 64KiB, >= 64KiB).
+ * See comments in the code for more information.
  *
  *  \see surf_workstation_model_init_SMPI()
  */
 XBT_PUBLIC(void) surf_network_model_init_SMPI(void);
 
-/** \brief Initializes the platform with the network model 'LagrangeVelho'
+/** \brief Initializes the platform with the network model 'LegrandVelho'
  *  \ingroup SURF_models
- *  \param filename XML platform file name
  *
  * This model is proposed by Arnaud Legrand and Pedro Velho based on
  * the results obtained with the GTNets simulator for onelink and
- * dogbone sharing scenarios.
+ * dogbone sharing scenarios. See comments in the code for more information.
  *
  *  \see surf_workstation_model_init_LegrandVelho()
  */
 XBT_PUBLIC(void) surf_network_model_init_LegrandVelho(void);
 
-
-/** \brief Initializes the platform with the network model 'LV08_im'
- *  \ingroup SURF_models
- *  \param filename XML platform file name
- *
- * This model is adds the lazy management improvement to Legrand and
- * Velho model. This improvement essentially replaces the list of actions
- * inside the simulation kernel by a heap in order to reduce the complexity
- * at each iteration of the simulation kernel.
- *
- *  \see surf_workstation_model_init_LegrandVelho()
- */
-XBT_PUBLIC(void) im_surf_network_model_init_LegrandVelho(void);
-
 /** \brief Initializes the platform with the network model 'Constant'
  *  \ingroup SURF_models
- *  \param filename XML platform file name
  *
  *  In this model, the communication time between two network cards is
  *  constant, hence no need for a routing table. This is particularly
@@ -436,10 +462,10 @@ XBT_PUBLIC(void) surf_network_model_init_Constant(void);
 
 /** \brief Initializes the platform with the network model CM02
  *  \ingroup SURF_models
- *  \param filename XML platform file name
  *
  *  This function is called by surf_workstation_model_init_CLM03
  *  or by yourself only if you plan using surf_workstation_model_init_compound
+ *  See comments in the code for more information.
  *
  *  \see surf_workstation_model_init_CLM03()
  */
@@ -556,7 +582,6 @@ XBT_PUBLIC_DATA(surf_model_t) surf_workstation_model;
 
 /** \brief Initializes the platform with a compound workstation model
  *  \ingroup SURF_models
- *  \param filename XML platform file name
  *
  *  This function should be called after a cpu_model and a
  *  network_model have been set up.
@@ -564,9 +589,20 @@ XBT_PUBLIC_DATA(surf_model_t) surf_workstation_model;
  */
 XBT_PUBLIC(void) surf_workstation_model_init_compound(void);
 
+/** \brief Initializes the platform with the current best network and cpu models at hand
+ *  \ingroup SURF_models
+ *
+ *  This platform model seperates the workstation model and the network model.
+ *  The workstation model will be initialized with the model compound, the network
+ *  model with the model LV08 (with cross traffic support) and the CPU model with
+ *  the model Cas01.
+ *  Such model is subject to modification with warning in the ChangeLog so monitor it!
+ *
+ */
+XBT_PUBLIC(void) surf_workstation_model_init_current_default(void);
+
 /** \brief Initializes the platform with the workstation model CLM03
  *  \ingroup SURF_models
- *  \param filename XML platform file name
  *
  *  This platform model seperates the workstation model and the network model.
  *  The workstation model will be initialized with the model CLM03, the network
@@ -574,26 +610,11 @@ XBT_PUBLIC(void) surf_workstation_model_init_compound(void);
  *  In future releases, some other network models will be implemented and will be
  *  combined with the workstation model CLM03.
  *
- *  \see surf_workstation_model_init_KCCFLN05()
  */
 XBT_PUBLIC(void) surf_workstation_model_init_CLM03(void);
 
 /** \brief Initializes the platform with the model KCCFLN05
  *  \ingroup SURF_models
- *  \param filename XML platform file name
- *
- *  With this model, the workstations and the network are handled
- *  together. The network model is roughly the same as in CM02 but
- *  interference between computations and communications can be taken
- *  into account. This platform model is the default one for MSG and
- *  SimDag.
- *
- */
-XBT_PUBLIC(void) surf_workstation_model_init_KCCFLN05(void);
-
-/** \brief Initializes the platform with the model KCCFLN05
- *  \ingroup SURF_models
- *  \param filename XML platform file name
  *
  *  With this model, only parallel tasks can be used. Resource sharing
  *  is done by identifying bottlenecks and giving an equal share of
@@ -626,11 +647,9 @@ XBT_PUBLIC_DATA(xbt_cfg_t) _surf_cfg_set;
  *  This function has to be called to initialize the common
  *  structures.  Then you will have to create the environment by
  *  calling 
- *  e.g. surf_workstation_model_init_CLM03() or
- *  surf_workstation_model_init_KCCFLN05().
+ *  e.g. surf_workstation_model_init_CLM03()
  *
- *  \see surf_workstation_model_init_CLM03(),
- *  surf_workstation_model_init_KCCFLN05(), surf_workstation_model_init_compound(), surf_exit()
+ *  \see surf_workstation_model_init_CLM03(), surf_workstation_model_init_compound(), surf_exit()
  */
 XBT_PUBLIC(void) surf_init(int *argc, char **argv);     /* initialize common structures */
 
@@ -659,7 +678,7 @@ XBT_PUBLIC(double) surf_solve(double max_date);
  *
  *  Return the current time in millisecond.
  */
-XBT_INLINE XBT_PUBLIC(double) surf_get_clock(void);
+XBT_PUBLIC(double) surf_get_clock(void);
 
 /** \brief Exit SURF
  *  \ingroup SURF_simulation
@@ -672,8 +691,7 @@ XBT_PUBLIC(void) surf_exit(void);
 
 /* Prototypes of the functions that handle the properties */
 XBT_PUBLIC_DATA(xbt_dict_t) current_property_set;       /* the prop set for the currently parsed element (also used in SIMIX) */
-XBT_PUBLIC_DATA(void) parse_properties(const char* prop_id, const char* prop_value);
-XBT_PUBLIC_DATA(void) parse_properties_XML(void);
+XBT_PUBLIC(void) parse_properties(void);
 
 /* surf parse file related (public because called from a test suite) */
 XBT_PUBLIC(void) parse_platform_file(const char *file);
@@ -692,5 +710,8 @@ XBT_PUBLIC_DATA(xbt_dict_t) trace_connect_list_latency;
 
 XBT_PUBLIC(double) get_cpu_power(const char *power);
 
+int surf_get_nthreads(void);
+void surf_set_nthreads(int nthreads);
+
 SG_END_DECL()
 #endif                          /* _SURF_SURF_H */