#include "xbt/dict.h"
#include "xbt/graph.h"
#include "xbt/misc.h"
-#include "xbt/file_stat.h"
#include "portable.h"
#include "xbt/config.h"
#include "surf/datatypes.h"
extern double sg_latency_factor;
extern double sg_bandwidth_factor;
extern double sg_weight_S_parameter;
-extern int sg_maxmin_selective_update;
extern int sg_network_crosstraffic;
#ifdef HAVE_GTNETS
extern double sg_gtnets_jitter;
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
char *category; /**< tracing category for categorized resource utilization monitoring */
#endif
surf_file_t file; /**< surf_file_t for storage model */
- s_file_stat_t stat; /**< surf_file_t for storage model */
xbt_dict_t ls_dict;
} s_surf_action_t;
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);
void (*add_traces) (void);
*/
typedef struct surf_storage_model_extension_public {
- surf_action_t(*open) (void *storage, const char* mount, const char* path, const char* mode);
- surf_action_t(*close) (void *storage, surf_file_t fp);
- surf_action_t(*read) (void *storage, void* ptr, double size, size_t nmemb, surf_file_t stream);
- surf_action_t(*write) (void *storage, const void* ptr, size_t size, size_t nmemb, surf_file_t stream);
- surf_action_t(*stat) (void *storage, surf_file_t stream);
- surf_action_t(*unlink) (void *storage, surf_file_t stream);
+ surf_action_t(*open) (void *storage, const char* mount, const char* path);
+ surf_action_t(*close) (void *storage, surf_file_t fd);
+ surf_action_t(*read) (void *storage, void* ptr, size_t size,
+ surf_file_t fd);
+ surf_action_t(*write) (void *storage, const void* ptr, size_t size,
+ surf_file_t fd);
+ surf_action_t(*stat) (void *storage, surf_file_t fd);
surf_action_t(*ls) (void *storage, const char *path);
} s_surf_model_extension_storage_t;
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 */
surf_action_t(*communicate) (void *workstation_src, /**< Execute a communication amount between two workstations */
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* storage, 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, surf_file_t stream);
- surf_action_t(*unlink) (void *workstation, surf_file_t stream);
+ surf_action_t(*open) (void *workstation, const char* storage,
+ const char* path);
+ surf_action_t(*close) (void *workstation, surf_file_t fd);
+ surf_action_t(*read) (void *workstation, void* ptr, size_t size,
+ surf_file_t fd);
+ surf_action_t(*write) (void *workstation, const void* ptr, size_t size,
+ surf_file_t fd);
+ surf_action_t(*stat) (void *workstation, surf_file_t fd);
+ int(*unlink) (void *workstation, surf_file_t fd);
surf_action_t(*ls) (void *workstation, const char* mount, const char *path);
+ size_t (*get_size) (void *workstation, surf_file_t fd);
int (*link_shared) (const void *link);
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 {
* */
s_surf_model_extension_workstation_t basic;
- void (*create) (const char *name, void *ind_phys_workstation); // First operation of the VM model
// start does not appear here as it corresponds to turn the state from created to running (see smx_vm.c)
- int (*get_state) (void *ind_vm_workstation);
- void (*set_state) (void *ind_vms_workstation, int state);
- void (*migrate) (void *ind_vm_workstation, void *ind_dest_phys_workstation); // will be vm_ws_migrate()
- const char * (*get_phys_host) (void *ind_vm_workstation); // will be vm_ws_get_phys_host()
- void (*destroy) (void *ind_vm_workstation); // will be vm_ws_destroy(), which destroies the vm-workstation-specific data
+
+ 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
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
return xbt_lib_get_elm_or_null(storage_lib, name);
}
+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
*/
* 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.
- *
- * \see surf_workstation_model_init_CLM03()
+ * You shouldn't have to call it by yourself.
*/
XBT_PUBLIC(void) surf_cpu_model_init_Cas01(void);
* \brief Initializes the CPU model with trace integration [Deprecated]
*
* You shouldn't have to call it by yourself.
- * \see surf_workstation_model_init_CLM03()
*/
XBT_PUBLIC(surf_model_t) surf_cpu_model_init_ti(void);
-/** \brief This function call the share resources function needed
- *
- */
-XBT_PUBLIC(double) generic_share_resources(double now);
-
-/** \brief This function call the update action state function needed
- *
- */
-XBT_PUBLIC(void) generic_update_actions_state(double now, double delta);
-
/** \ingroup SURF_models
* \brief The list of all available optimization modes (both for cpu and networks).
* These optimization modes can be set using --cfg=cpu/optim:... and --cfg=network/optim:...
*/
XBT_PUBLIC_DATA(s_surf_model_description_t) surf_cpu_model_description[];
-XBT_PUBLIC(void) create_workstations(void);
-
/**\brief create new host bypass the parser
*
*/
/** \ingroup SURF_models
* \brief Initializes the platform with the network model CM02
*
- * This function is called by surf_workstation_model_init_CLM03
- * or by yourself only if you plan using surf_workstation_model_init_compound
+ * You sould call this function 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()
*/
XBT_PUBLIC(void) surf_network_model_init_CM02(void);
-/**
- * brief initialize the the network model bypassing the XML parser
- */
-XBT_PUBLIC(void) surf_network_model_init_bypass(const char *id,
- double initial_bw,
- double initial_lat);
-
#ifdef HAVE_GTNETS
/** \ingroup SURF_models
* \brief Initializes the platform with the network model GTNETS
*/
XBT_PUBLIC(void) surf_workstation_model_init_current_default(void);
-/** \ingroup SURF_models
- * \brief Initializes the platform with the workstation model CLM03
- *
- * This platform model seperates the workstation model and the network model.
- * The workstation model will be initialized with the model CLM03, the network
- * model with the model CM02 and the CPU model with the model Cas01.
- * In future releases, some other network models will be implemented and will be
- * combined with the workstation model CLM03.
- *
- */
-XBT_PUBLIC(void) surf_workstation_model_init_CLM03(void);
-
/** \ingroup SURF_models
* \brief Initializes the platform with the model KCCFLN05
*
XBT_PUBLIC_DATA(xbt_dynar_t) model_list;
XBT_PUBLIC_DATA(xbt_dynar_t) model_list_invoke;
+/*******************************************/
+/*** SURF Platform *************************/
+/*******************************************/
+typedef struct s_as *AS_t;
+
+XBT_PUBLIC_DATA(AS_t) surf_AS_get_routing_root(void);
+XBT_PUBLIC_DATA(const char *) surf_AS_get_name(AS_t as);
+XBT_PUBLIC_DATA(xbt_dict_t) surf_AS_get_routing_sons(AS_t as);
+XBT_PUBLIC_DATA(const char *) surf_AS_get_model(AS_t as);
+XBT_PUBLIC_DATA(xbt_dynar_t) surf_AS_get_hosts(AS_t as);
+
/*******************************************/
/*** SURF Globals **************************/
/*******************************************/
* 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()
+ * e.g. surf_workstation_model_init_CM02()
*
- * \see surf_workstation_model_init_CLM03(), surf_workstation_model_init_compound(), surf_exit()
+ * \see surf_workstation_model_init_CM02(), surf_workstation_model_init_compound(), surf_exit()
*/
XBT_PUBLIC(void) surf_init(int *argc, char **argv); /* initialize common structures */
/* 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(void) parse_properties(void);
/* surf parse file related (public because called from a test suite) */
XBT_PUBLIC(void) parse_platform_file(const char *file);
-/* Stores the sets */
-XBT_PUBLIC_DATA(xbt_dict_t) set_list;
-
/* For the trace and trace:connect tag (store their content till the end of the parsing) */
XBT_PUBLIC_DATA(xbt_dict_t) traces_set_list;
XBT_PUBLIC_DATA(xbt_dict_t) trace_connect_list_host_avail;
