X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/6e8a5aeab4a376b73cdcbe116d2437af319cafc3..58a6a9307ec328557fb80333cf4631ead71e4ebd:/src/surf/xml/surfxml_sax_cb.cpp diff --git a/src/surf/xml/surfxml_sax_cb.cpp b/src/surf/xml/surfxml_sax_cb.cpp index 314c276f9f..13de767561 100644 --- a/src/surf/xml/surfxml_sax_cb.cpp +++ b/src/surf/xml/surfxml_sax_cb.cpp @@ -7,23 +7,37 @@ #include "simgrid/sg_config.h" #include "src/kernel/routing/NetPoint.hpp" #include "src/surf/network_interface.hpp" -#include "xbt/file.h" +#include "xbt/file.hpp" #include "src/surf/xml/platf_private.hpp" #include #include #include +#include #include +#include +#include +#include XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_parse, surf, "Logging specific to the SURF parsing module"); -SG_BEGIN_DECL() +extern "C" { int ETag_surfxml_include_state(); #include "simgrid_dtd.c" -char* surf_parsed_filename = nullptr; // to locate parse error messages +/* + * Stuff relative to the tag + */ +static std::vector surf_input_buffer_stack; +static std::vector surf_file_to_parse_stack; +static std::vector surf_parsed_filename_stack; + +static inline const char* surf_parsed_filename() // to locate parse error messages +{ + return surf_parsed_filename_stack.empty() ? nullptr : surf_parsed_filename_stack.back().c_str(); +} std::vector parsed_link_list; /* temporary store of current list link of a route */ @@ -35,45 +49,42 @@ void surf_parse_assert(bool cond, std::string msg) if (not cond) { int lineno = surf_parse_lineno; cleanup(); - XBT_ERROR("Parse error at %s:%d: %s", surf_parsed_filename, lineno, msg.c_str()); + XBT_ERROR("Parse error at %s:%d: %s", surf_parsed_filename(), lineno, msg.c_str()); surf_exit(); xbt_die("Exiting now"); } } + void surf_parse_error(std::string msg) { int lineno = surf_parse_lineno; cleanup(); - XBT_ERROR("Parse error at %s:%d: %s", surf_parsed_filename, lineno, msg.c_str()); + XBT_ERROR("Parse error at %s:%d: %s", surf_parsed_filename(), lineno, msg.c_str()); surf_exit(); xbt_die("Exiting now"); } -void surf_parse_assert_netpoint(char* hostname, const char* pre, const char* post) +void surf_parse_assert_netpoint(std::string hostname, std::string pre, std::string post) { - if (sg_netpoint_by_name_or_null(hostname) != nullptr) // found + if (sg_netpoint_by_name_or_null(hostname.c_str()) != nullptr) // found return; - std::string msg = std::string(pre); - msg += hostname; - msg += post; - msg += " Existing netpoints: \n"; + std::string msg = pre + hostname + post + " Existing netpoints: \n"; std::vector list; simgrid::s4u::Engine::getInstance()->getNetpointList(&list); - std::sort(list.begin(), list.end(), - [](simgrid::kernel::routing::NetPoint* a, simgrid::kernel::routing::NetPoint* b) { - return a->name() < b->name(); + std::sort(list.begin(), list.end(), [](simgrid::kernel::routing::NetPoint* a, simgrid::kernel::routing::NetPoint* b) { + return a->getName() < b->getName(); }); bool first = true; - for (auto np : list) { + for (auto const& np : list) { if (np->isNetZone()) continue; if (not first) msg += ","; first = false; - msg += "'" + np->name() + "'"; + msg += "'" + np->getName() + "'"; if (msg.length() > 4096) { msg.pop_back(); // remove trailing quote msg += "...(list truncated)......"; @@ -83,51 +94,54 @@ void surf_parse_assert_netpoint(char* hostname, const char* pre, const char* pos surf_parse_error(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); +void surf_parse_warn(std::string msg) +{ + XBT_WARN("%s:%d: %s", surf_parsed_filename(), surf_parse_lineno, msg.c_str()); } -double surf_parse_get_double(const char *string) { - double res; - int ret = sscanf(string, "%lg", &res); - if (ret != 1) - surf_parse_error(std::string(string) + " is not a double"); - return res; +double surf_parse_get_double(std::string s) +{ + try { + return std::stod(s); + } catch (std::invalid_argument& ia) { + surf_parse_error(s + " is not a double"); + return -1; + } } -int surf_parse_get_int(const char *string) { - int res; - int ret = sscanf(string, "%d", &res); - if (ret != 1) - surf_parse_error(std::string(string) + " is not an integer"); - return res; +int surf_parse_get_int(std::string s) +{ + try { + return std::stoi(s); + } catch (std::invalid_argument& ia) { + surf_parse_error(s + " is not a double"); + return -1; + } +} } +namespace { + /* Turn something like "1-4,6,9-11" into the vector {1,2,3,4,6,9,10,11} */ -static std::vector* explodesRadical(const char* radicals) +std::vector* explodesRadical(std::string radicals) { std::vector* exploded = new std::vector(); // Make all hosts std::vector radical_elements; boost::split(radical_elements, radicals, boost::is_any_of(",")); - for (auto group : radical_elements) { + for (auto const& group : radical_elements) { std::vector radical_ends; boost::split(radical_ends, group, boost::is_any_of("-")); - int start = surf_parse_get_int((radical_ends.front()).c_str()); - int end = 0; + int start = surf_parse_get_int(radical_ends.front()); + int end = 0; switch (radical_ends.size()) { case 1: end = start; break; case 2: - end = surf_parse_get_int((radical_ends.back()).c_str()); + end = surf_parse_get_int(radical_ends.back()); break; default: surf_parse_error(std::string("Malformed radical: ") + group); @@ -140,17 +154,49 @@ static std::vector* explodesRadical(const char* radicals) return exploded; } -struct unit_scale { - const char *unit; - double scale; +class unit_scale : public std::unordered_map { +public: + using std::unordered_map::unordered_map; + // tuples are : + explicit unit_scale(std::initializer_list> generators); }; +unit_scale::unit_scale(std::initializer_list> generators) +{ + for (const auto& gen : generators) { + const std::string& unit = std::get<0>(gen); + double value = std::get<1>(gen); + const int base = std::get<2>(gen); + const bool abbrev = std::get<3>(gen); + double mult; + std::vector prefixes; + switch (base) { + case 2: + mult = 1024.0; + prefixes = abbrev ? std::vector{"Ki", "Mi", "Gi", "Ti", "Pi", "Ei", "Zi", "Yi"} + : std::vector{"kibi", "mebi", "gibi", "tebi", "pebi", "exbi", "zebi", "yobi"}; + break; + case 10: + mult = 1000.0; + prefixes = abbrev ? std::vector{"k", "M", "G", "T", "P", "E", "Z", "Y"} + : std::vector{"kilo", "mega", "giga", "tera", "peta", "exa", "zeta", "yotta"}; + break; + default: + THROW_IMPOSSIBLE; + } + emplace(unit, value); + for (const auto& prefix : prefixes) { + value *= mult; + emplace(prefix + unit, value); + } + } +} + /* Note: field `unit' for the last element of parameter `units' should be nullptr. */ -static double surf_parse_get_value_with_unit(const char *string, const struct unit_scale *units, - const char *entity_kind, const char *name, const char *error_msg, const char *default_unit) +double surf_parse_get_value_with_unit(const char* string, const unit_scale& units, const char* entity_kind, + std::string name, const char* error_msg, const char* default_unit) { char* ptr; - int i; errno = 0; double res = strtod(string, &ptr); if (errno == ERANGE) @@ -161,132 +207,58 @@ static double surf_parse_get_value_with_unit(const char *string, const struct un if (res == 0) return res; // Ok, 0 can be unit-less - XBT_WARN("Deprecated unit-less value '%s' for %s %s. %s",string, entity_kind, name, error_msg); + XBT_WARN("Deprecated unit-less value '%s' for %s %s. %s", string, entity_kind, name.c_str(), error_msg); ptr = (char*)default_unit; } - for (i = 0; units[i].unit != nullptr && strcmp(ptr, units[i].unit) != 0; i++); - - if (units[i].unit != nullptr) - res *= units[i].scale; - else + auto u = units.find(ptr); + if (u == units.end()) surf_parse_error(std::string("unknown unit: ") + ptr); - return res; + return res * u->second; +} } -double surf_parse_get_time(const char *string, const char *entity_kind, const char *name) +extern "C" { + +double surf_parse_get_time(const char* string, const char* entity_kind, std::string name) { - const struct unit_scale units[] = { - { "w", 7 * 24 * 60 * 60 }, - { "d", 24 * 60 * 60 }, - { "h", 60 * 60 }, - { "m", 60 }, - { "s", 1.0 }, - { "ms", 1e-3 }, - { "us", 1e-6 }, - { "ns", 1e-9 }, - { "ps", 1e-12 }, - { nullptr, 0 } - }; + static const unit_scale units{std::make_pair("w", 7 * 24 * 60 * 60), + std::make_pair("d", 24 * 60 * 60), + std::make_pair("h", 60 * 60), + std::make_pair("m", 60), + std::make_pair("s", 1.0), + std::make_pair("ms", 1e-3), + std::make_pair("us", 1e-6), + std::make_pair("ns", 1e-9), + std::make_pair("ps", 1e-12)}; return surf_parse_get_value_with_unit(string, units, entity_kind, name, "Append 's' to your time to get seconds", "s"); } -double surf_parse_get_size(const char *string, const char *entity_kind, const char *name) +double surf_parse_get_size(const char* string, const char* entity_kind, std::string name) { - const struct unit_scale units[] = { - { "EiB", pow(1024, 6) }, - { "PiB", pow(1024, 5) }, - { "TiB", pow(1024, 4) }, - { "GiB", pow(1024, 3) }, - { "MiB", pow(1024, 2) }, - { "KiB", 1024 }, - { "EB", 1e18 }, - { "PB", 1e15 }, - { "TB", 1e12 }, - { "GB", 1e9 }, - { "MB", 1e6 }, - { "kB", 1e3 }, - { "B", 1.0 }, - { "Eib", 0.125 * pow(1024, 6) }, - { "Pib", 0.125 * pow(1024, 5) }, - { "Tib", 0.125 * pow(1024, 4) }, - { "Gib", 0.125 * pow(1024, 3) }, - { "Mib", 0.125 * pow(1024, 2) }, - { "Kib", 0.125 * 1024 }, - { "Eb", 0.125 * 1e18 }, - { "Pb", 0.125 * 1e15 }, - { "Tb", 0.125 * 1e12 }, - { "Gb", 0.125 * 1e9 }, - { "Mb", 0.125 * 1e6 }, - { "kb", 0.125 * 1e3 }, - { "b", 0.125 }, - { nullptr, 0 } - }; + static const unit_scale units{std::make_tuple("b", 0.125, 2, true), std::make_tuple("b", 0.125, 10, true), + std::make_tuple("B", 1.0, 2, true), std::make_tuple("B", 1.0, 10, true)}; return surf_parse_get_value_with_unit(string, units, entity_kind, name, "Append 'B' to get bytes (or 'b' for bits but 1B = 8b).", "B"); } -double surf_parse_get_bandwidth(const char *string, const char *entity_kind, const char *name) +double surf_parse_get_bandwidth(const char* string, const char* entity_kind, std::string name) { - const struct unit_scale units[] = { - { "EiBps", pow(1024, 6) }, - { "PiBps", pow(1024, 5) }, - { "TiBps", pow(1024, 4) }, - { "GiBps", pow(1024, 3) }, - { "MiBps", pow(1024, 2) }, - { "KiBps", 1024 }, - { "EBps", 1e18 }, - { "PBps", 1e15 }, - { "TBps", 1e12 }, - { "GBps", 1e9 }, - { "MBps", 1e6 }, - { "kBps", 1e3 }, - { "Bps", 1.0 }, - { "Eibps", 0.125 * pow(1024, 6) }, - { "Pibps", 0.125 * pow(1024, 5) }, - { "Tibps", 0.125 * pow(1024, 4) }, - { "Gibps", 0.125 * pow(1024, 3) }, - { "Mibps", 0.125 * pow(1024, 2) }, - { "Kibps", 0.125 * 1024 }, - { "Tbps", 0.125 * 1e12 }, - { "Gbps", 0.125 * 1e9 }, - { "Mbps", 0.125 * 1e6 }, - { "kbps", 0.125 * 1e3 }, - { "bps", 0.125 }, - { nullptr, 0 } - }; + static const unit_scale units{std::make_tuple("bps", 0.125, 2, true), std::make_tuple("bps", 0.125, 10, true), + std::make_tuple("Bps", 1.0, 2, true), std::make_tuple("Bps", 1.0, 10, true)}; return surf_parse_get_value_with_unit(string, units, entity_kind, name, "Append 'Bps' to get bytes per second (or 'bps' for bits but 1Bps = 8bps)", "Bps"); } -double surf_parse_get_speed(const char *string, const char *entity_kind, const char *name) +double surf_parse_get_speed(const char* string, const char* entity_kind, std::string name) { - const struct unit_scale units[] = { - { "yottaflops", 1e24 }, - { "Yf", 1e24 }, - { "zettaflops", 1e21 }, - { "Zf", 1e21 }, - { "exaflops", 1e18 }, - { "Ef", 1e18 }, - { "petaflops", 1e15 }, - { "Pf", 1e15 }, - { "teraflops", 1e12 }, - { "Tf", 1e12 }, - { "gigaflops", 1e9 }, - { "Gf", 1e9 }, - { "megaflops", 1e6 }, - { "Mf", 1e6 }, - { "kiloflops", 1e3 }, - { "kf", 1e3 }, - { "flops", 1.0 }, - { "f", 1.0 }, - { nullptr, 0 } - }; + static const unit_scale units{std::make_tuple("f", 1.0, 10, true), std::make_tuple("flops", 1.0, 10, false)}; return surf_parse_get_value_with_unit(string, units, entity_kind, name, "Append 'f' or 'flops' to your speed to get flop per second", "f"); } -static std::vector surf_parse_get_all_speeds(char* speeds, const char* entity_kind, const char* id){ +static std::vector surf_parse_get_all_speeds(char* speeds, const char* entity_kind, std::string id) +{ std::vector speed_per_pstate; @@ -382,19 +354,12 @@ void ETag_surfxml_mount() sg_platf_new_mount(&mount); } -/* - * Stuff relative to the tag - */ -static std::vector surf_input_buffer_stack; -static std::vector surf_file_to_parse_stack; -static std::vector surf_parsed_filename_stack; - void STag_surfxml_include() { + XBT_ERROR(" tag is deprecated, and will be removed in SimGrid v3.18. Please stop using it now (or tell us why you need it)."); parse_after_config(); XBT_DEBUG("STag_surfxml_include '%s'",A_surfxml_include_file); - surf_parsed_filename_stack.push_back(surf_parsed_filename); // save old file name - surf_parsed_filename = xbt_strdup(A_surfxml_include_file); + surf_parsed_filename_stack.emplace_back(A_surfxml_include_file); // save file name surf_file_to_parse_stack.push_back(surf_file_to_parse); // save old file descriptor @@ -439,7 +404,6 @@ int ETag_surfxml_include_state() surf_input_buffer_stack.pop_back(); // Restore the filename for error messages - free(surf_parsed_filename); surf_parsed_filename_stack.pop_back(); return 1; @@ -480,19 +444,19 @@ void STag_surfxml_platform() { "Use simgrid_update_xml to update your file automatically. " "This program is installed automatically with SimGrid, or " "available in the tools/ directory of the source archive.", - surf_parsed_filename, version); + surf_parsed_filename(), version); if (version < 4.1) { XBT_INFO("You're using a v%.1f XML file (%s) while the current standard is v4.1 " "That's fine, the new version is backward compatible. \n\n" "Use simgrid_update_xml to update your file automatically. " "This program is installed automatically with SimGrid, or " "available in the tools/ directory of the source archive.", - version, surf_parsed_filename); + version, surf_parsed_filename()); } xbt_assert(version <= 4.1, "******* FILE %s COMES FROM THE FUTURE (v:%.1f) *********\n " "The most recent formalism that this version of SimGrid understands is v4.1.\n" "Please update your code, or use another, more adapted, file.", - surf_parsed_filename, version); + surf_parsed_filename(), version); sg_platf_begin(); } @@ -544,8 +508,7 @@ void ETag_surfxml_host() { void STag_surfxml_host___link(){ XBT_DEBUG("Create a Host_link for %s",A_surfxml_host___link_id); - s_sg_platf_host_link_cbarg_t host_link; - memset(&host_link,0,sizeof(host_link)); + HostLinkCreationArgs host_link; host_link.id = A_surfxml_host___link_id; host_link.link_up = A_surfxml_host___link_up; @@ -558,9 +521,8 @@ void STag_surfxml_router(){ } void ETag_surfxml_cluster(){ - s_sg_platf_cluster_cbarg_t cluster; - memset(&cluster,0,sizeof(cluster)); - cluster.properties = current_property_set; + ClusterCreationArgs cluster; + cluster.properties = current_property_set; current_property_set = nullptr; cluster.id = A_surfxml_cluster_id; @@ -706,28 +668,24 @@ void ETag_surfxml_link(){ sg_platf_new_link(&link); } -void STag_surfxml_link___ctn(){ - +void STag_surfxml_link___ctn() +{ simgrid::surf::LinkImpl* link = nullptr; - char *link_name=nullptr; switch (A_surfxml_link___ctn_direction) { case AU_surfxml_link___ctn_direction: case A_surfxml_link___ctn_direction_NONE: link = simgrid::surf::LinkImpl::byName(A_surfxml_link___ctn_id); break; case A_surfxml_link___ctn_direction_UP: - link_name = bprintf("%s_UP", A_surfxml_link___ctn_id); - link = simgrid::surf::LinkImpl::byName(link_name); + link = simgrid::surf::LinkImpl::byName(std::string(A_surfxml_link___ctn_id) + "_UP"); break; case A_surfxml_link___ctn_direction_DOWN: - link_name = bprintf("%s_DOWN", A_surfxml_link___ctn_id); - link = simgrid::surf::LinkImpl::byName(link_name); + link = simgrid::surf::LinkImpl::byName(std::string(A_surfxml_link___ctn_id) + "_DOWN"); break; default: - surf_parse_error(std::string("Invalid direction for link ") + link_name); + surf_parse_error(std::string("Invalid direction for link ") + A_surfxml_link___ctn_id); break; } - xbt_free(link_name); // no-op if it's already nullptr const char* dirname = ""; switch (A_surfxml_link___ctn_direction) { @@ -805,7 +763,7 @@ void ETag_surfxml_route(){ route.link_list = new std::vector(); route.symmetrical = (A_surfxml_route_symmetrical == A_surfxml_route_symmetrical_YES); - for (auto link: parsed_link_list) + for (auto const& link : parsed_link_list) route.link_list->push_back(link); parsed_link_list.clear(); @@ -835,7 +793,7 @@ void ETag_surfxml_zoneRoute() ASroute.link_list = new std::vector(); - for (auto link: parsed_link_list) + for (auto const& link : parsed_link_list) ASroute.link_list->push_back(link); parsed_link_list.clear(); @@ -847,6 +805,8 @@ void ETag_surfxml_zoneRoute() case A_surfxml_zoneRoute_symmetrical_NO: ASroute.symmetrical = false; break; + default: + THROW_IMPOSSIBLE; } sg_platf_new_route(&ASroute); @@ -864,7 +824,7 @@ void ETag_surfxml_bypassRoute(){ route.symmetrical = false; route.link_list = new std::vector(); - for (auto link: parsed_link_list) + for (auto const& link : parsed_link_list) route.link_list->push_back(link); parsed_link_list.clear(); @@ -888,7 +848,7 @@ void ETag_surfxml_bypassZoneRoute() ASroute.src = sg_netpoint_by_name_or_null(A_surfxml_bypassZoneRoute_src); ASroute.dst = sg_netpoint_by_name_or_null(A_surfxml_bypassZoneRoute_dst); ASroute.link_list = new std::vector(); - for (auto link: parsed_link_list) + for (auto const& link : parsed_link_list) ASroute.link_list->push_back(link); parsed_link_list.clear(); @@ -916,7 +876,6 @@ void STag_surfxml_trace___connect() { parse_after_config(); TraceConnectCreationArgs trace_connect; - memset(&trace_connect,0,sizeof(trace_connect)); trace_connect.element = A_surfxml_trace___connect_element; trace_connect.trace = A_surfxml_trace___connect_trace; @@ -976,7 +935,8 @@ void ETag_surfxml_zone() void STag_surfxml_config() { ZONE_TAG = 0; - xbt_assert(current_property_set == nullptr, "Someone forgot to reset the property set to nullptr in its closing tag (or XML malformed)"); + xbt_assert(current_property_set == nullptr, + "Someone forgot to reset the property set to nullptr in its closing tag (or XML malformed)"); XBT_DEBUG("START configuration name = %s",A_surfxml_config_id); if (_sg_cfg_init_status == 2) { surf_parse_error("All tags must be given before any platform elements (such as , , , " @@ -986,7 +946,7 @@ void STag_surfxml_config() void ETag_surfxml_config() { - for (auto elm : *current_property_set) { + for (auto const& elm : *current_property_set) { if (xbt_cfg_is_default_value(elm.first.c_str())) { std::string cfg = elm.first + ":" + elm.second; xbt_cfg_set_parse(cfg.c_str()); @@ -1007,6 +967,7 @@ void STag_surfxml_process() AX_surfxml_actor_function = AX_surfxml_process_function; STag_surfxml_actor(); } + void STag_surfxml_actor() { ZONE_TAG = 0; @@ -1025,14 +986,17 @@ void ETag_surfxml_process() AX_surfxml_actor_on___failure = (AT_surfxml_actor_on___failure)AX_surfxml_process_on___failure; ETag_surfxml_actor(); } + void ETag_surfxml_actor() { s_sg_platf_process_cbarg_t actor; memset(&actor,0,sizeof(actor)); + actor.properties = current_property_set; + current_property_set = nullptr; + actor.argc = argc; actor.argv = (const char **)argv; - actor.properties = current_property_set; actor.host = A_surfxml_actor_host; actor.function = A_surfxml_actor_function; actor.start_time = surf_parse_get_double(A_surfxml_actor_start___time); @@ -1057,8 +1021,6 @@ void ETag_surfxml_actor() xbt_free(argv[i]); xbt_free(argv); argv = nullptr; - - current_property_set = nullptr; } void STag_surfxml_argument(){ @@ -1071,8 +1033,7 @@ void STag_surfxml_model___prop(){ if (not current_model_property_set) current_model_property_set = new std::map(); - current_model_property_set->insert( - {std::string(A_surfxml_model___prop_id), std::string(A_surfxml_model___prop_value)}); + current_model_property_set->insert({A_surfxml_model___prop_id, A_surfxml_model___prop_value}); } void ETag_surfxml_prop(){/* Nothing to do */} @@ -1094,10 +1055,9 @@ void surf_parse_open(const char *file) { xbt_assert(file, "Cannot parse the nullptr file. Bypassing the parser is strongly deprecated nowadays."); - surf_parsed_filename = xbt_strdup(file); - char* dir = xbt_dirname(file); - surf_path.push_back(std::string(dir)); - xbt_free(dir); + surf_parsed_filename_stack.emplace_back(file); + std::string dir = simgrid::xbt::Path(file).getDirname(); + surf_path.push_back(dir); surf_file_to_parse = surf_fopen(file, "r"); if (surf_file_to_parse == nullptr) @@ -1109,12 +1069,11 @@ void surf_parse_open(const char *file) void surf_parse_close() { - if (surf_parsed_filename) { + if (surf_parsed_filename()) { surf_path.pop_back(); } - free(surf_parsed_filename); - surf_parsed_filename = nullptr; + surf_parsed_filename_stack.pop_back(); if (surf_file_to_parse) { surf_parse__delete_buffer(surf_input_buffer); @@ -1128,5 +1087,4 @@ int surf_parse() { return surf_parse_lex(); } - -SG_END_DECL() +}