typedef struct msg_file *msg_file_t;
/* ******************************** Storage ************************************ */
-typedef struct simdata_storage *simdata_storage_t;
-
-typedef struct msg_storage {
- char *name;
- simdata_storage_t simdata; /**< @brief simulator data */
- void *data; /**< @brief user data */
-} s_msg_storage_t;
-
-typedef struct msg_storage *msg_storage_t;
+/* TODO: PV: to comment */
+
+extern int MSG_STORAGE_LEVEL;
+
+typedef xbt_dictelm_t msg_storage_t;
+typedef s_xbt_dictelm_t s_msg_storage_t;
+
+typedef struct msg_storage_priv {
+/* TODO PV: fill it (or not) ! */
+} s_msg_storage_priv_t, *msg_storage_priv_t;
+
+//typedef struct simdata_storage *simdata_storage_t;
+//
+//typedef struct msg_storage {
+// char *name;
+// simdata_storage_t simdata; /**< @brief simulator data */
+// void *data; /**< @brief user data */
+//} s_msg_storage_t;
+//
+//typedef struct msg_storage *msg_storage_t;
/*************** Begin GPU ***************/
typedef struct simdata_gpu_task *simdata_gpu_task_t;
XBT_PUBLIC(void) __MSG_file_get_info(msg_file_t fd);
/************************** Storage handling ***********************************/
+XBT_PUBLIC(msg_host_t) MSG_get_storage_by_name(const char *name);
+XBT_PUBLIC(const char *) MSG_storage_get_name(msg_storage_t storage);
XBT_PUBLIC(size_t) MSG_storage_get_free_size(const char* name);
XBT_PUBLIC(size_t) MSG_storage_get_used_size(const char* name);
XBT_PUBLIC(msg_storage_t) MSG_storage_get_by_name(const char *name);
XBT_PUBLIC(xbt_dict_t) MSG_storage_get_properties(msg_storage_t storage);
XBT_PUBLIC(xbt_dynar_t) MSG_storages_as_dynar(void);
+XBT_PUBLIC(msg_error_t) MSG_storage_set_data(msg_storage_t host, void *data);
+XBT_PUBLIC(void *) MSG_storage_get_data(msg_storage_t storage);
/************************** AS Router handling ************************************/
XBT_PUBLIC(const char *) MSG_as_router_get_property_value(const char* asr, const char *name);
XBT_PUBLIC(xbt_dict_t) MSG_as_router_get_properties(const char* asr);
} e_SD_task_kind_t;
+/** @brief Storage datatype
+ @ingroup SD_datatypes_management
+
+ TODO PV: comment it !
+
+ @see SD_storage_management */
+typedef xbt_dictelm_t SD_storage_t;
+
#endif
return host->key;
}
+typedef xbt_dictelm_t sg_storage_t;
+static inline char* sg_storage_name(sg_storage_t storage) {
+ return storage->key;
+}
+
+
/*
* Platform creation functions. Instead of passing 123 arguments to the creation functions
typedef struct s_smx_sem *smx_sem_t;
/********************************** File *************************************/
+
typedef struct s_smx_file *smx_file_t;
/********************************** Storage *************************************/
-typedef struct s_smx_storage *smx_storage_t;
+typedef xbt_dictelm_t smx_storage_t;
+typedef struct s_smx_storage_priv *smx_storage_priv_t;
/********************************** Action *************************************/
typedef struct s_smx_action *smx_action_t; /* FIXME: replace by specialized action handlers */
XBT_PUBLIC(void*) SIMIX_host_get_data(smx_host_t host);
XBT_PUBLIC(void) SIMIX_host_set_data(smx_host_t host, void *data);
XBT_PUBLIC(xbt_dynar_t) SIMIX_host_get_storage_list(smx_host_t host);
+XBT_PUBLIC(const char*) SIMIX_storage_get_name(smx_host_t host);
/********************************* Process ************************************/
XBT_PUBLIC(int) SIMIX_process_count(void);
XBT_PUBLIC(size_t) simcall_storage_get_free_size (const char* name);
XBT_PUBLIC(size_t) simcall_storage_get_used_size (const char* name);
XBT_PUBLIC(xbt_dict_t) simcall_storage_get_properties(smx_storage_t storage);
+XBT_PUBLIC(void*) SIMIX_storage_get_data(smx_storage_t storage);
+XBT_PUBLIC(void) SIMIX_storage_set_data(smx_storage_t storage, void *data);
/************************** AS router **********************************/
XBT_PUBLIC(xbt_dict_t) SIMIX_asr_get_properties(const char *name);
XBT_PUBLIC(int) ROUTING_HOST_LEVEL; //Routing level
XBT_PUBLIC(int) SURF_CPU_LEVEL; //Surf cpu level
XBT_PUBLIC(int) SURF_WKS_LEVEL; //Surf workstation level
-XBT_PUBLIC(int) SIMIX_HOST_LEVEL; //Simix level
+XBT_PUBLIC(int) SIMIX_HOST_LEVEL; //Simix host level
+XBT_PUBLIC(int) SIMIX_STORAGE_LEVEL; //Simix storage level
XBT_PUBLIC(int) MSG_HOST_LEVEL; //Msg level
-XBT_PUBLIC(int) SD_HOST_LEVEL; //Simdag level
+XBT_PUBLIC(int) SD_HOST_LEVEL; //Simdag host level
+XBT_PUBLIC(int) SD_STORAGE_LEVEL; //Simdag storage level
XBT_PUBLIC(int) COORD_HOST_LEVEL; //Coordinates level
XBT_PUBLIC(int) NS3_HOST_LEVEL; //host node for ns3
XBT_PUBLIC(xbt_lib_t) storage_lib;
XBT_PUBLIC(int) ROUTING_STORAGE_LEVEL; //Routing storage level
XBT_PUBLIC(int) ROUTING_STORAGE_HOST_LEVEL;
-XBT_PUBLIC(int) SURF_STORAGE_LEVEL;
+XBT_PUBLIC(int) SURF_STORAGE_LEVEL; // Surf storage level
XBT_PUBLIC(xbt_lib_t) storage_type_lib;
XBT_PUBLIC(int) ROUTING_STORAGE_TYPE_LEVEL; //Routing storage_type level
if(data[SIMIX_HOST_LEVEL])
__MSG_host_create(xbt_dict_cursor_get_elm(cursor));
}
+
+ /* Initialize MSG storages */
+ xbt_lib_foreach(storage_lib, cursor, name, data) {
+ if(data[SIMIX_STORAGE_LEVEL])
+ __MSG_storage_create(xbt_dict_cursor_get_elm(cursor));
+ }
+
}
msg_as_t MSG_environment_get_routing_root() {
XBT_DEBUG("ADD MSG LEVELS");
MSG_HOST_LEVEL = xbt_lib_add_level(host_lib, (void_f_pvoid_t) __MSG_host_destroy);
+ MSG_STORAGE_LEVEL = xbt_lib_add_level(storage_lib, (void_f_pvoid_t) __MSG_storage_destroy);
atexit(MSG_exit);
}
*
*/
+
+/* TODO: PV: to comment */
+msg_storage_t __MSG_storage_create(smx_storage_t storage)
+{
+ const char *name = SIMIX_storage_get_name(storage);
+ xbt_lib_set(storage_lib,name,MSG_HOST_LEVEL,storage);
+ return xbt_lib_get_elm_or_null(storage_lib, name);
+}
+
+/*
+ * \brief Destroys a storage (internal call only)
+ */
+void __MSG_storage_destroy(msg_storage_priv_t storage) {
+
+ free(storage);
+}
+
+/** \ingroup msg_storage_management
+ *
+ * \brief Returns the name of the #msg_storage_t.
+ *
+ * This functions checks whether a storage is a valid pointer or not and return its name.
+ */
+const char *MSG_storage_get_name(msg_storage_t storage) {
+ return SIMIX_storage_get_name(storage);
+}
+
+/** \ingroup msg_storage_management
+ * \brief Finds a msg_storage_t using its name.
+ * \param name the name of a storage.
+ * \return the corresponding storage
+ */
+msg_host_t MSG_get_storage_by_name(const char *name)
+{
+ return (msg_storage_t) xbt_lib_get_elm_or_null(storage_lib,name);
+}
+
/** \ingroup msg_storage_management
* \brief Returns the free space size of a storage element
* \param the storage name (#char*)
xbt_dict_t MSG_storage_get_properties(msg_storage_t storage)
{
xbt_assert((storage != NULL), "Invalid parameters (storage is NULL)");
- return (simcall_storage_get_properties(storage->simdata->smx_storage));
+ return (simcall_storage_get_properties(storage));
}
/** \ingroup msg_storage_management
/** \ingroup msg_storage_management
* \brief Returns a dynar containing all the storage elements declared at a given point of time
*
- *
- *
- * @TODO implement a new msg_storage_t structure that hides members (use xbt_dict)
*/
xbt_dynar_t MSG_storages_as_dynar(void) {
char *key;
void **data;
xbt_dynar_t res = xbt_dynar_new(sizeof(msg_storage_t),NULL);
- msg_storage_t storage;
+
xbt_lib_foreach(storage_lib, cursor, key, data) {
- if(routing_get_network_element_type(key) == ROUTING_STORAGE_LEVEL) {
+ if(routing_get_network_element_type(key) == MSG_STORAGE_LEVEL) {
xbt_dictelm_t elm = xbt_dict_cursor_get_elm(cursor);
- storage = xbt_new(s_msg_storage_t, 1);
- storage->name = elm->key;
- storage->simdata = xbt_new0(s_simdata_storage_t,1);
- smx_storage_t simix_storage = xbt_lib_get_or_null(storage_lib, elm->key, SURF_STORAGE_LEVEL);
- storage->simdata->smx_storage = simix_storage;
- storage->data = NULL;
- xbt_dynar_push(res, &storage);
+ xbt_dynar_push(res, &elm);
}
}
return res;
}
+
+/** \ingroup msg_storage_management
+ *
+ * \brief Set the user data of a #msg_storage_t.
+ * This functions checks whether some data has already been associated to \a storage
+ or not and attach \a data to \a storage if it is possible.
+ */
+msg_error_t MSG_storage_set_data(msg_storage_t storage, void *data)
+{
+ SIMIX_storage_set_data(storage,data);
+
+ return MSG_OK;
+}
+
+
+
+/** \ingroup msg_host_management
+ *
+ * \brief Return the user data of a #msg_storage_t.
+ *
+ * This functions checks whether \a storage is a valid pointer or not and return
+ the user data associated to \a storage if it is possible.
+ */
+void *MSG_storage_get_data(msg_storage_t storage)
+{
+ return SIMIX_storage_get_data(storage);
+}
+
+
+
+
+
+
+
+
+
#endif
msg_host_t __MSG_host_create(smx_host_t workstation);
+msg_storage_t __MSG_storage_create(smx_storage_t storage);
void __MSG_host_destroy(msg_host_priv_t host);
+void __MSG_storage_destroy(msg_storage_priv_t host);
void MSG_process_cleanup_from_SIMIX(smx_process_t smx_proc);
void MSG_process_create_from_SIMIX(smx_process_t *process, const char *name,
return xbt_lib_get_level(host, SD_HOST_LEVEL);
}
+/* Storage */
+typedef s_xbt_dictelm_t s_SD_storage_t;
+typedef struct SD_storage {
+ void *data; /* user data */
+} s_SD_storage_priv_t, *SD_storage_priv_t;
+
+
/* Task */
typedef struct SD_task {
s_xbt_swag_hookup_t state_hookup;
{
return task->state_set == sd_global->running_task_set;
}
+
+/********** Storage **********/
+SD_storage_t __SD_storage_create(void *surf_storage, void *data);
+void __SD_storage_destroy(void *storage);
+
/********** Tracing **********/
/* declaration of instrumentation functions from sd_task_instr.c */
void TRACE_sd_task_create(SD_task_t task);
XBT_DEBUG("ADD SD LEVELS");
SD_HOST_LEVEL = xbt_lib_add_level(host_lib,__SD_workstation_destroy);
SD_LINK_LEVEL = xbt_lib_add_level(link_lib,__SD_link_destroy);
+ SD_STORAGE_LEVEL = xbt_lib_add_level(storage_lib,__SD_storage_destroy);
}
/** \brief set a configuration variable
char *name = NULL;
void **surf_workstation = NULL;
void **surf_link = NULL;
+ void **surf_storage = NULL;
parse_platform_file(platform_file);
- /* now let's create the SD wrappers for workstations and links */
+ /* now let's create the SD wrappers for workstations, storages and links */
xbt_lib_foreach(host_lib, cursor, name, surf_workstation){
if(surf_workstation[SURF_WKS_LEVEL])
__SD_workstation_create(surf_workstation[SURF_WKS_LEVEL], NULL);
__SD_link_create(surf_link[SURF_LINK_LEVEL], NULL);
}
+ xbt_lib_foreach(storage_lib, cursor, name, surf_storage) {
+ if(surf_storage[SURF_LINK_LEVEL])
+ __SD_storage_create(surf_link[SURF_STORAGE_LEVEL], NULL);
+ }
+
+
XBT_DEBUG("Workstation number: %d, link number: %d",
SD_workstation_get_number(), SD_link_get_number());
#ifdef HAVE_JEDULE
return xbt_lib_get_elm_or_null(host_lib,name);
}
+/* Creates a storage and registers it in SD.
+ */
+SD_storage_t __SD_storage_create(void *surf_storage, void *data)
+{
+
+ SD_storage_priv_t storage;
+ const char *name;
+
+ storage = xbt_new(s_SD_storage_priv_t, 1);
+ storage->data = data; /* user data */
+
+ name = surf_resource_name(surf_storage);
+ xbt_lib_set(storage_lib,name, SD_STORAGE_LEVEL, storage);
+ return xbt_lib_get_elm_or_null(storage_lib, name);
+}
+
+/* Destroys a storage.
+ */
+void __SD_storage_destroy(void *storage)
+{
+ xbt_free(storage);
+}
+
/**
* \brief Returns a workstation given its name
*
void SIMIX_post_create_environment(void) {
void **workstation = NULL;
+ void **storage = NULL;
xbt_lib_cursor_t cursor = NULL;
char *name = NULL;
+ /* Create host at SIMIX level */
xbt_lib_foreach(host_lib, cursor, name, workstation) {
if(workstation[SURF_WKS_LEVEL])
SIMIX_host_create(name, workstation[SURF_WKS_LEVEL], NULL);
}
+
+ /* Create storage at SIMIX level */
+ xbt_lib_foreach(storage_lib, cursor, name, storage) {
+ if(storage[SURF_STORAGE_LEVEL])
+ SIMIX_storage_create(name, storage[SURF_STORAGE_LEVEL], NULL);
+ }
+
surf_presolve();
}
"Logging specific to SIMIX (io)");
+/**
+ * \brief Internal function to create a SIMIX storage.
+ * \param name name of the storage to create
+ * \param storage the SURF storage to encapsulate
+ * \param data some user data (may be NULL)
+ */
+smx_host_t SIMIX_storage_create(const char *name, void *storage, void *data)
+{
+ smx_storage_priv_t smx_storage = xbt_new0(s_smx_storage_priv_t, 1);
+
+ smx_storage->data = data;
+
+ /* Update global variables */
+ xbt_lib_set(storage_lib,name,SIMIX_STORAGE_LEVEL,smx_storage);
+ return xbt_lib_get_elm_or_null(storage_lib, name);
+}
+
+
void* SIMIX_pre_file_get_data(smx_simcall_t simcall,smx_file_t fd){
return SIMIX_file_get_data(fd);
}
return surf_storage_model->extension.storage.get_properties(storage);
}
+const char* SIMIX_storage_get_name(smx_storage_t storage){
+ xbt_assert((storage != NULL), "Invalid parameters");
+
+ return sg_storage_name(storage);
+}
+
+void SIMIX_pre_storage_set_data(smx_simcall_t simcall, smx_storage_t storage, void *data) {
+ SIMIX_storage_set_data(storage, data);
+}
+void SIMIX_storage_set_data(smx_storage_t storage, void *data){
+ xbt_assert((storage != NULL), "Invalid parameters");
+ xbt_assert((SIMIX_storage_priv(storage)->data == NULL), "Data already set");
+
+ SIMIX_storage_priv(storage)->data = data;
+}
+
+void* SIMIX_pre_storage_get_data(smx_simcall_t simcall,smx_storage_t storage){
+ return SIMIX_storage_get_data(storage);
+}
+void* SIMIX_storage_get_data(smx_storage_t storage){
+ xbt_assert((storage != NULL), "Invalid parameters (simix storage is NULL)");
+
+ return SIMIX_storage_priv(storage)->data;
+}
+
void SIMIX_post_io(smx_action_t action)
{
xbt_fifo_item_t i;
#include "simgrid/simix.h"
#include "smx_smurf_private.h"
+static inline smx_storage_priv_t SIMIX_storage_priv(smx_storage_t storage){
+ return xbt_lib_get_level(storage, SIMIX_STORAGE_LEVEL);
+}
+
+smx_storage_t SIMIX_storage_create(const char *name, void *storage, void *data);
void* SIMIX_pre_file_get_data(smx_simcall_t simcall,smx_file_t fd);
void SIMIX_pre_file_set_data(smx_simcall_t simcall, smx_file_t fd, void *data);
void SIMIX_pre_file_read(smx_simcall_t simcall, size_t size, smx_file_t fd);
xbt_dict_t SIMIX_storage_get_properties(smx_storage_t storage);
xbt_dict_t SIMIX_pre_storage_get_properties(smx_simcall_t, smx_storage_t);
+void SIMIX_pre_storage_set_data(smx_simcall_t, smx_storage_t, void*);
+void* SIMIX_pre_storage_get_data(smx_simcall_t, smx_storage_t);
+
void SIMIX_post_io(smx_action_t action);
void SIMIX_io_destroy(smx_action_t action);
void SIMIX_io_finish(smx_action_t action);
void* data; /**< @brief user data */
} s_smx_file_t;
-/* ******************************** Storage ************************************ */
-typedef struct s_smx_storage {
- surf_storage_t surf_storage;
-} s_smx_storage_t;
+/* ******************************** Storage ************************************/
+typedef struct s_smx_storage_priv {
+ void *data; /**< @brief user data */
+} s_smx_storage_priv_t;
/*********************************** Time ************************************/
int ROUTING_HOST_LEVEL; //Routing level
int SURF_CPU_LEVEL; //Surf cpu level
int SURF_WKS_LEVEL; //Surf workstation level
-int SIMIX_HOST_LEVEL; //Simix level
-int SIMIX_STORAGE_LEVEL; //Simix level
+int SIMIX_HOST_LEVEL; //Simix host level
+int SIMIX_STORAGE_LEVEL; //Simix storage level
int MSG_HOST_LEVEL; //Msg host level
-int SD_HOST_LEVEL; //Simdag level
+int MSG_STORAGE_LEVEL; //Msg storage level
+int SD_HOST_LEVEL; //Simdag host level
+int SD_STORAGE_LEVEL; //Simdag storage level
int COORD_HOST_LEVEL=0; //Coordinates level
int NS3_HOST_LEVEL; //host node for ns3
