/* This program is free software; you can redistribute it and/or modify it
* under the terms of the license (GNU LGPL) which comes with this package. */
+#include <stdarg.h> /* va_arg */
+
#include "xbt/misc.h"
#include "xbt/log.h"
#include "xbt/str.h"
/*
* Helping functions
*/
-void surf_parse_error(const char *msg) {
- xbt_die("Parse error at %s:%d: %s\n", surf_parsed_filename, surf_parse_lineno, msg);
+void surf_parse_error(const char *fmt, ...) {
+ va_list va;
+ va_start(va,fmt);
+ char *msg = bvprintf(fmt,va);
+ va_end(va);
+ xbt_die("Parse error at %s:%d: %s", surf_parsed_filename, surf_parse_lineno, msg);
+}
+void surf_parse_warn(const char *fmt, ...) {
+ va_list va;
+ va_start(va,fmt);
+ char *msg = bvprintf(fmt,va);
+ va_end(va);
+ XBT_WARN("%s:%d: %s", surf_parsed_filename, surf_parse_lineno, msg);
+ free(msg);
}
double surf_parse_get_double(const char *string) {
double res;
int ret = sscanf(string, "%lg", &res);
if (ret != 1)
- surf_parse_error(bprintf("%s is not a double", string));
+ surf_parse_error("%s is not a double", string);
return res;
}
int res;
int ret = sscanf(string, "%d", &res);
if (ret != 1)
- surf_parse_error(bprintf("%s is not an integer", string));
+ surf_parse_error("%s is not an integer", string);
return res;
}
/*
- * All the callback lists that can be overiden anywhere.
+ * All the callback lists that can be overridden anywhere.
* (this list should probably be reduced to the bare minimum to allow the models to work)
*/
xbt_dynar_t STag_surfxml_include_cb_list = NULL;
xbt_dynar_t ETag_surfxml_include_cb_list = NULL;
+xbt_dynar_t STag_surfxml_storage_cb_list = NULL;
+xbt_dynar_t ETag_surfxml_storage_cb_list = NULL;
+xbt_dynar_t STag_surfxml_storage_type_cb_list = NULL;
+xbt_dynar_t ETag_surfxml_storage_type_cb_list = NULL;
+xbt_dynar_t STag_surfxml_mount_cb_list = NULL;
+xbt_dynar_t ETag_surfxml_mount_cb_list = NULL;
+xbt_dynar_t STag_surfxml_mstorage_cb_list = NULL;
+xbt_dynar_t ETag_surfxml_mstorage_cb_list = NULL;
+
/* The default current property receiver. Setup in the corresponding opening callbacks. */
xbt_dict_t current_property_set = NULL;
/* dictionary of random generator data */
static void init_randomness(void);
static void add_randomness(void);
+/*
+ * Stuff relative to storage
+ */
+void STag_surfxml_storage(void)
+{
+ XBT_DEBUG("STag_surfxml_storage");
+}
+void ETag_surfxml_storage(void)
+{
+ s_sg_platf_storage_cbarg_t storage;
+ memset(&storage,0,sizeof(storage));
+
+ storage.id = A_surfxml_storage_id;
+ storage.type_id = A_surfxml_storage_typeId;
+ sg_platf_new_storage(&storage);
+}
+void STag_surfxml_storage_type(void)
+{
+ XBT_DEBUG("STag_surfxml_storage_type");
+ xbt_assert(current_property_set == NULL, "Someone forgot to reset the property set to NULL in its closing tag (or XML malformed)");
+}
+void ETag_surfxml_storage_type(void)
+{
+ s_sg_platf_storage_type_cbarg_t storage_type;
+ memset(&storage_type,0,sizeof(storage_type));
+
+ storage_type.content = A_surfxml_storage_type_content;
+ storage_type.id = A_surfxml_storage_type_id;
+ storage_type.model = A_surfxml_storage_type_model;
+ storage_type.properties = current_property_set;
+ sg_platf_new_storage_type(&storage_type);
+ current_property_set = NULL;
+}
+void STag_surfxml_mstorage(void)
+{
+ XBT_DEBUG("STag_surfxml_mstorage");
+}
+void ETag_surfxml_mstorage(void)
+{
+ s_sg_platf_mstorage_cbarg_t mstorage;
+ memset(&mstorage,0,sizeof(mstorage));
+
+ mstorage.name = A_surfxml_mstorage_name;
+ mstorage.type_id = A_surfxml_mstorage_typeId;
+ sg_platf_new_mstorage(&mstorage);
+}
+void STag_surfxml_mount(void)
+{
+ XBT_DEBUG("STag_surfxml_mount");
+}
+void ETag_surfxml_mount(void)
+{
+ s_sg_platf_mount_cbarg_t mount;
+ memset(&mount,0,sizeof(mount));
+
+ mount.name = A_surfxml_mount_name;
+ mount.id = A_surfxml_mount_id;
+ sg_platf_new_mount(&mount);
+}
+
/*
* Stuff relative to the <include> tag
*/
xbt_dynar_new(sizeof(void_f_void_t), NULL);
ETag_surfxml_include_cb_list =
xbt_dynar_new(sizeof(void_f_void_t), NULL);
+
+ STag_surfxml_storage_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
+ ETag_surfxml_storage_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
+ STag_surfxml_storage_type_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
+ ETag_surfxml_storage_type_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
+ STag_surfxml_mount_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
+ ETag_surfxml_mount_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
+ STag_surfxml_mstorage_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
+ ETag_surfxml_mstorage_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
}
void surf_parse_reset_callbacks(void)
xbt_dynar_free(&ETag_surfxml_peer_cb_list);
xbt_dynar_free(&STag_surfxml_include_cb_list);
xbt_dynar_free(&ETag_surfxml_include_cb_list);
+
+ xbt_dynar_free(&STag_surfxml_storage_cb_list);
+ xbt_dynar_free(&ETag_surfxml_storage_cb_list);
+ xbt_dynar_free(&STag_surfxml_mstorage_cb_list);
+ xbt_dynar_free(&ETag_surfxml_mstorage_cb_list);
+ xbt_dynar_free(&STag_surfxml_mount_cb_list);
+ xbt_dynar_free(&ETag_surfxml_mount_cb_list);
+ xbt_dynar_free(&STag_surfxml_storage_type_cb_list);
+ xbt_dynar_free(&ETag_surfxml_storage_type_cb_list);
}
/* Stag and Etag parse functions */
cluster.sharing_policy = SURF_LINK_FATPIPE;
break;
default:
- surf_parse_error(bprintf
- ("Invalid cluster sharing policy for cluster %s",
- cluster.id));
+ surf_parse_error("Invalid cluster sharing policy for cluster %s",
+ cluster.id);
break;
}
switch (AX_surfxml_cluster_bb_sharing_policy) {
cluster.bb_sharing_policy = SURF_LINK_SHARED;
break;
default:
- surf_parse_error(bprintf
- ("Invalid bb sharing policy in cluster %s",
- cluster.id));
+ surf_parse_error("Invalid bb sharing policy in cluster %s",
+ cluster.id);
break;
}
link.state = SURF_RESOURCE_OFF;
break;
default:
- surf_parse_error(bprintf("invalid state for link %s",link.id));
+ surf_parse_error("invalid state for link %s", link.id);
break;
}
link.state_trace = tmgr_trace_new(A_surfxml_link_state_file);
link.policy = SURF_LINK_FULLDUPLEX;
break;
default:
- surf_parse_error(bprintf("Invalid sharing policy in link %s",link.id));
+ surf_parse_error("Invalid sharing policy in link %s", link.id);
break;
}
#define parse_method(type,name) \
void type##Tag_surfxml_##name(void) \
{ surfxml_call_cb_functions(type##Tag_surfxml_##name##_cb_list); }
-parse_method(E, route);
-parse_method(E, link_ctn);
-parse_method(E, process);
-parse_method(E, argument);
-parse_method(E, prop);
-parse_method(E, trace);
-parse_method(E, trace_connect);
-parse_method(E, random);
-parse_method(E, ASroute);
-parse_method(E, bypassRoute);
+parse_method(E, route)
+parse_method(E, link_ctn)
+parse_method(E, process)
+parse_method(E, argument)
+parse_method(E, prop)
+parse_method(E, trace)
+parse_method(E, trace_connect)
+parse_method(E, random)
+parse_method(E, ASroute)
+parse_method(E, bypassRoute)
/* Open and Close parse file */
return power_scale;
}
-double random_min, random_max, random_mean, random_std_deviation,
- random_generator;
+double random_min, random_max, random_mean, random_std_deviation;
+e_random_generator_t random_generator;
char *random_id;
static void init_randomness(void)
random_max = surf_parse_get_double(A_surfxml_random_max);
random_mean = surf_parse_get_double(A_surfxml_random_mean);
random_std_deviation = surf_parse_get_double(A_surfxml_random_std_deviation);
- random_generator = A_surfxml_random_generator;
+ switch (A_surfxml_random_generator) {
+ case AU_surfxml_random_generator:
+ case A_surfxml_random_generator_NONE:
+ random_generator = NONE;
+ break;
+ case A_surfxml_random_generator_DRAND48:
+ random_generator = DRAND48;
+ break;
+ case A_surfxml_random_generator_RAND:
+ random_generator = RAND;
+ break;
+ case A_surfxml_random_generator_RNGSTREAM:
+ random_generator = RNGSTREAM;
+ break;
+ default:
+ surf_parse_error("Invalid random generator");
+ break;
+ }
}
static void add_randomness(void)