#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 <boost/algorithm/string.hpp>
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();
std::vector<simgrid::kernel::routing::NetPoint*> 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)......";
// Make all hosts
std::vector<std::string> radical_elements;
boost::split(radical_elements, radicals, boost::is_any_of(","));
- for (auto group : radical_elements) {
+ for (auto const& group : radical_elements) {
std::vector<std::string> radical_ends;
boost::split(radical_ends, group, boost::is_any_of("-"));
int start = surf_parse_get_int(radical_ends.front());
};
/* 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, std::string name, const char* error_msg,
- const char* default_unit)
+static 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;
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 }
- };
+ const 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}};
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, 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 }
- };
+ const 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}};
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, 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 }
- };
+ const 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}};
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, 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 }
- };
+ const 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}};
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");
}
void STag_surfxml_include()
{
+ XBT_ERROR("<include> 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
route.link_list = new std::vector<simgrid::surf::LinkImpl*>();
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();
ASroute.link_list = new std::vector<simgrid::surf::LinkImpl*>();
- for (auto link: parsed_link_list)
+ for (auto const& link : parsed_link_list)
ASroute.link_list->push_back(link);
parsed_link_list.clear();
case A_surfxml_zoneRoute_symmetrical_NO:
ASroute.symmetrical = false;
break;
+ default:
+ THROW_IMPOSSIBLE;
}
sg_platf_new_route(&ASroute);
route.symmetrical = false;
route.link_list = new std::vector<simgrid::surf::LinkImpl*>();
- for (auto link: parsed_link_list)
+ for (auto const& link : parsed_link_list)
route.link_list->push_back(link);
parsed_link_list.clear();
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<simgrid::surf::LinkImpl*>();
- for (auto link: parsed_link_list)
+ for (auto const& link : parsed_link_list)
ASroute.link_list->push_back(link);
parsed_link_list.clear();
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());
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);
xbt_free(argv[i]);
xbt_free(argv);
argv = nullptr;
-
- current_property_set = nullptr;
}
void STag_surfxml_argument(){
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);
+ 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)
{
return surf_parse_lex();
}
-
-SG_END_DECL()
+}
