sg_size_t getSizeUsed();
std::map<std::string, std::string>* getProperties();
- const char* getProperty(const char* key);
- void setProperty(const char* key, const char* value);
+ const char* getProperty(std::string key);
+ void setProperty(std::string, std::string value);
std::map<std::string, sg_size_t>* getContent();
void setUserdata(void* data) { userdata_ = data; }
/* Set the value of the cell \a name in \a cfg with the provided value.*/
XBT_PUBLIC(void) xbt_cfg_set_int (const char *name, int val);
XBT_PUBLIC(void) xbt_cfg_set_double (const char *name, double val);
-XBT_PUBLIC(void) xbt_cfg_set_string (const char *name, const char *val);
XBT_PUBLIC(void) xbt_cfg_set_boolean (const char *name, const char *val);
XBT_PUBLIC(void) xbt_cfg_set_as_string(const char *name, const char *val);
XBT_PUBLIC(int) xbt_cfg_get_int(const char *name);
XBT_PUBLIC(double) xbt_cfg_get_double(const char *name);
-XBT_PUBLIC(char *) xbt_cfg_get_string(const char *name);
XBT_PUBLIC(int) xbt_cfg_get_boolean(const char *name);
/** @} */
}
}
+XBT_PUBLIC(std::string) xbt_cfg_get_string(const char* name);
+XBT_PUBLIC(void) xbt_cfg_set_string(const char* name, std::string val);
#endif
#include "simgrid/msg.h"
+#include "include/xbt/signal.hpp"
#include "jmsg.hpp"
#include "jmsg_storage.h"
#include "jxbt_utilities.hpp"
+#include "simgrid/s4u/Storage.hpp"
XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(java);
}
const char *name = env->GetStringUTFChars((jstring) jname, 0);
const char *value_java = env->GetStringUTFChars((jstring) jvalue, 0);
- char *value = xbt_strdup(value_java);
- MSG_storage_set_property_value(storage, name, value);
+ storage->setProperty(name, std::string(value_java));
env->ReleaseStringUTFChars((jstring) jvalue, value_java);
env->ReleaseStringUTFChars((jstring) jname, name);
extern XBT_PRIVATE int _sg_mc_checkpoint;
extern XBT_PUBLIC(int) _sg_mc_sparse_checkpoint;
extern XBT_PUBLIC(int) _sg_mc_ksm;
-extern XBT_PUBLIC(char*) _sg_mc_property_file;
extern XBT_PRIVATE int _sg_mc_timeout;
extern XBT_PRIVATE int _sg_mc_hash;
extern XBT_PRIVATE int _sg_mc_max_depth;
extern XBT_PUBLIC(int) _sg_mc_max_visited_states;
-extern XBT_PRIVATE char* _sg_mc_dot_output_file;
extern XBT_PUBLIC(int) _sg_mc_comms_determinism;
extern XBT_PUBLIC(int) _sg_mc_send_determinism;
extern XBT_PRIVATE int _sg_mc_snapshot_fds;
#define SIMGRID_CONFIG_H
#include "xbt/config.h"
+#include "xbt/config.hpp"
/** Config Globals */
SG_BEGIN_DECL()
SG_END_DECL()
-#endif
\ No newline at end of file
+#endif
#define SMPI_UTILS_HPP
#include "xbt/base.h"
#include <cstddef>
+#include <string>
#include <vector>
extern "C" {
typedef s_smpi_factor_t* smpi_os_factor_t;
}
-XBT_PUBLIC(std::vector<s_smpi_factor_t>) parse_factor(const char *smpi_coef_string);
+XBT_PUBLIC(std::vector<s_smpi_factor_t>) parse_factor(std::string smpi_coef_string);
#endif
const char *description;
void_f_void_t model_init_preparse;
};
-typedef struct surf_model_description s_surf_model_description_t;
-typedef struct surf_model_description* surf_model_description_t;
+typedef struct surf_model_description s_surf_model_description_t;
-XBT_PUBLIC(int) find_model_description(s_surf_model_description_t * table, const char *name);
+#ifdef __cplusplus
+XBT_PUBLIC(int) find_model_description(s_surf_model_description_t* table, std::string name);
+#endif
XBT_PUBLIC(void) model_help(const char *category, s_surf_model_description_t * table);
/***************************/
/* 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 "include/xbt/config.hpp"
#include "src/instr/instr_private.hpp"
#include "surf/surf.h"
#include <string>
/* init the tracing module to generate the right output */
/* open the trace file(s) */
- const char* format = xbt_cfg_get_string(OPT_TRACING_FORMAT);
- XBT_DEBUG("Tracing format %s\n", format);
- if (not strcmp(format, "Paje")) {
+ std::string format = xbt_cfg_get_string(OPT_TRACING_FORMAT);
+ XBT_DEBUG("Tracing format %s\n", format.c_str());
+ if (format == "Paje") {
TRACE_paje_start();
- } else if (not strcmp(format, "TI")) {
+ } else if (format == "TI") {
instr_fmt_type = instr_fmt_TI;
TRACE_TI_start();
}else{
- xbt_die("Unknown trace format :%s ", format);
+ xbt_die("Unknown trace format :%s ", format.c_str());
}
/* activate trace */
delete root_type;
/* close the trace files */
- const char* format = xbt_cfg_get_string(OPT_TRACING_FORMAT);
- XBT_DEBUG("Tracing format %s\n", format);
- if (not strcmp(format, "Paje")) {
+ std::string format = xbt_cfg_get_string(OPT_TRACING_FORMAT);
+ XBT_DEBUG("Tracing format %s\n", format.c_str());
+ if (format == "Paje") {
TRACE_paje_end();
- } else if (not strcmp(format, "TI")) {
+ } else if (format == "TI") {
TRACE_TI_end();
}else{
- xbt_die("Unknown trace format :%s ", format);
+ xbt_die("Unknown trace format :%s ", format.c_str());
}
/* de-activate trace */
return trace_display_sizes && trace_smpi_enabled && TRACE_is_enabled();
}
-char *TRACE_get_comment ()
+std::string TRACE_get_comment()
{
return xbt_cfg_get_string(OPT_TRACING_COMMENT);
}
-char *TRACE_get_comment_file ()
+std::string TRACE_get_comment_file()
{
return xbt_cfg_get_string(OPT_TRACING_COMMENT_FILE);
}
return xbt_cfg_get_int(OPT_TRACING_PRECISION);
}
-char *TRACE_get_filename()
+std::string TRACE_get_filename()
{
return xbt_cfg_get_string(OPT_TRACING_FILENAME);
}
-char *TRACE_get_viva_uncat_conf ()
+std::string TRACE_get_viva_uncat_conf()
{
return xbt_cfg_get_string(OPT_VIVA_UNCAT_CONF);
}
-char *TRACE_get_viva_cat_conf ()
+std::string TRACE_get_viva_cat_conf()
{
return xbt_cfg_get_string(OPT_VIVA_CAT_CONF);
}
void TRACE_generate_viva_uncat_conf ()
{
- generate_uncat_configuration (TRACE_get_viva_uncat_conf (), "viva", 0);
+ generate_uncat_configuration(TRACE_get_viva_uncat_conf().c_str(), "viva", 0);
}
void TRACE_generate_viva_cat_conf ()
{
- generate_cat_configuration (TRACE_get_viva_cat_conf(), "viva", 0);
+ generate_cat_configuration(TRACE_get_viva_cat_conf().c_str(), "viva", 0);
}
static int previous_trace_state = -1;
}
if (not xbt_cfg_get_boolean("tracing/smpi/format/ti-one-file") || ti_unique_file == nullptr) {
- char* folder_name = bprintf("%s_files", TRACE_get_filename());
- char* filename = bprintf("%s/%f_%s.txt", folder_name, prefix, name_.c_str());
+ std::string folder_name = TRACE_get_filename() + "_files";
+ std::string filename = folder_name + "/" + std::to_string(prefix) + "_" + name_ + ".txt";
#ifdef WIN32
- _mkdir(folder_name);
+ _mkdir(folder_name.c_str());
#else
- mkdir(folder_name, S_IRWXU | S_IRWXG | S_IRWXO);
+ mkdir(folder_name.c_str(), S_IRWXU | S_IRWXG | S_IRWXO);
#endif
- ti_unique_file = fopen(filename, "w");
- xbt_assert(ti_unique_file, "Tracefile %s could not be opened for writing: %s", filename, strerror(errno));
- fprintf(tracing_file, "%s\n", filename);
-
- xbt_free(folder_name);
- xbt_free(filename);
+ ti_unique_file = fopen(filename.c_str(), "w");
+ xbt_assert(ti_unique_file, "Tracefile %s could not be opened for writing: %s", filename.c_str(), strerror(errno));
+ fprintf(tracing_file, "%s\n", filename.c_str());
}
tracing_files.insert({this, ti_unique_file});
} else {
insertIntoBuffer();
}
-LinkEvent::LinkEvent(double timestamp, container_t container, Type* type, e_event_type event_type, container_t endpoint,
+LinkEvent::LinkEvent(container_t container, Type* type, e_event_type event_type, container_t endpoint,
std::string value, std::string key)
- : LinkEvent(timestamp, container, type, event_type, endpoint, value, key, -1)
+ : LinkEvent(container, type, event_type, endpoint, value, key, -1)
{
}
-LinkEvent::LinkEvent(double timestamp, container_t container, Type* type, e_event_type event_type, container_t endpoint,
+LinkEvent::LinkEvent(container_t container, Type* type, e_event_type event_type, container_t endpoint,
std::string value, std::string key, int size)
- : PajeEvent(container, type, timestamp, event_type), endpoint_(endpoint), value_(value), key_(key), size_(size)
+ : PajeEvent(container, type, SIMIX_get_clock(), event_type)
+ , endpoint_(endpoint)
+ , value_(value)
+ , key_(key)
+ , size_(size)
{
XBT_DEBUG("%s: event_type=%u, timestamp=%f, value:%s", __FUNCTION__, eventType_, timestamp_, value_.c_str());
insertIntoBuffer();
insertIntoBuffer();
}
-StateEvent::StateEvent(double timestamp, Container* container, Type* type, e_event_type event_type, EntityValue* value)
- : StateEvent(timestamp, container, type, event_type, value, nullptr)
+StateEvent::StateEvent(Container* container, Type* type, e_event_type event_type, EntityValue* value)
+ : StateEvent(container, type, event_type, value, nullptr)
{
}
-StateEvent::StateEvent(double timestamp, Container* container, Type* type, e_event_type event_type, EntityValue* value,
- void* extra)
- : PajeEvent::PajeEvent(container, type, timestamp, event_type), value(value), extra_(extra)
+StateEvent::StateEvent(Container* container, Type* type, e_event_type event_type, EntityValue* value, void* extra)
+ : PajeEvent::PajeEvent(container, type, SIMIX_get_clock(), event_type), value(value), extra_(extra)
{
#if HAVE_SMPI
if (xbt_cfg_get_boolean("smpi/trace-call-location")) {
void* extra_ = nullptr;
public:
- StateEvent(double timestamp, Container* container, Type* type, e_event_type event_type, EntityValue* value);
- StateEvent(double timestamp, Container* container, Type* type, e_event_type event_type, EntityValue* value,
- void* extra);
+ StateEvent(Container* container, Type* type, e_event_type event_type, EntityValue* value);
+ StateEvent(Container* container, Type* type, e_event_type event_type, EntityValue* value, void* extra);
void print() override;
};
int size_ = -1;
public:
- LinkEvent(double timestamp, Container* container, Type* type, e_event_type event_type, Container* sourceContainer,
- std::string value, std::string key);
- LinkEvent(double timestamp, Container* container, Type* type, e_event_type event_type, Container* sourceContainer,
- std::string value, std::string key, int size);
+ LinkEvent(Container* container, Type* type, e_event_type event_type, Container* sourceContainer, std::string value,
+ std::string key);
+ LinkEvent(Container* container, Type* type, e_event_type event_type, Container* sourceContainer, std::string value,
+ std::string key, int size);
void print() override;
};
};
}
}
-
#endif
}
void TRACE_paje_start() {
- char *filename = TRACE_get_filename();
- tracing_file = fopen(filename, "w");
+ std::string filename = TRACE_get_filename();
+ tracing_file = fopen(filename.c_str(), "w");
if (tracing_file == nullptr){
- THROWF (system_error, 1, "Tracefile %s could not be opened for writing.", filename);
+ THROWF(system_error, 1, "Tracefile %s could not be opened for writing.", filename.c_str());
}
- XBT_DEBUG("Filename %s is open for writing", filename);
+ XBT_DEBUG("Filename %s is open for writing", filename.c_str());
/* output generator version */
fprintf (tracing_file, "#This file was generated using SimGrid-%d.%d.%d\n",
void TRACE_paje_end() {
fclose(tracing_file);
- char *filename = TRACE_get_filename();
- XBT_DEBUG("Filename %s is closed", filename);
+ XBT_DEBUG("Filename %s is closed", TRACE_get_filename().c_str());
}
void TRACE_TI_start()
{
- char *filename = TRACE_get_filename();
- tracing_file = fopen(filename, "w");
- if (tracing_file == nullptr)
- THROWF(system_error, 1, "Tracefile %s could not be opened for writing.", filename);
+ std::string filename = TRACE_get_filename();
+ tracing_file = fopen(filename.c_str(), "w");
+ if (tracing_file == nullptr) {
+ THROWF(system_error, 1, "Tracefile %s could not be opened for writing.", filename.c_str());
+ }
- XBT_DEBUG("Filename %s is open for writing", filename);
+ XBT_DEBUG("Filename %s is open for writing", filename.c_str());
/* output one line comment */
dump_comment(TRACE_get_comment());
void TRACE_TI_end()
{
fclose(tracing_file);
- XBT_DEBUG("Filename %s is closed", TRACE_get_filename());
+ XBT_DEBUG("Filename %s is closed", TRACE_get_filename().c_str());
}
void StateType::setEvent(std::string value_name)
{
- events_.push_back(new StateEvent(SIMIX_get_clock(), issuer_, this, PAJE_SetState, getEntityValue(value_name)));
+ events_.push_back(new StateEvent(issuer_, this, PAJE_SetState, getEntityValue(value_name)));
}
void StateType::pushEvent(std::string value_name, void* extra)
{
- events_.push_back(
- new StateEvent(SIMIX_get_clock(), issuer_, this, PAJE_PushState, getEntityValue(value_name), extra));
+ events_.push_back(new StateEvent(issuer_, this, PAJE_PushState, getEntityValue(value_name), extra));
}
void StateType::pushEvent(std::string value_name)
{
- events_.push_back(new StateEvent(SIMIX_get_clock(), issuer_, this, PAJE_PushState, getEntityValue(value_name)));
+ events_.push_back(new StateEvent(issuer_, this, PAJE_PushState, getEntityValue(value_name)));
}
void StateType::popEvent()
{
- events_.push_back(new StateEvent(SIMIX_get_clock(), issuer_, this, PAJE_PopState, nullptr));
+ events_.push_back(new StateEvent(issuer_, this, PAJE_PopState, nullptr));
}
VariableType::VariableType(std::string name, std::string color, Type* father) : Type(name, name, color, father)
void LinkType::startEvent(container_t startContainer, std::string value, std::string key, int size)
{
- new LinkEvent(SIMIX_get_clock(), issuer_, this, PAJE_StartLink, startContainer, value, key, size);
+ new LinkEvent(issuer_, this, PAJE_StartLink, startContainer, value, key, size);
}
void LinkType::endEvent(container_t endContainer, std::string value, std::string key)
{
- new LinkEvent(SIMIX_get_clock(), issuer_, this, PAJE_EndLink, endContainer, value, key);
+ new LinkEvent(issuer_, this, PAJE_EndLink, endContainer, value, key);
}
void Type::logDefinition(e_event_type event_type)
XBT_PRIVATE bool TRACE_disable_destroy();
XBT_PRIVATE bool TRACE_basic();
XBT_PRIVATE bool TRACE_display_sizes();
-XBT_PRIVATE char* TRACE_get_comment();
-XBT_PRIVATE char* TRACE_get_comment_file();
XBT_PRIVATE int TRACE_precision();
-XBT_PRIVATE char* TRACE_get_filename();
-XBT_PRIVATE char* TRACE_get_viva_uncat_conf();
-XBT_PRIVATE char* TRACE_get_viva_cat_conf();
+XBT_PRIVATE std::string TRACE_get_comment();
+XBT_PRIVATE std::string TRACE_get_comment_file();
+XBT_PRIVATE std::string TRACE_get_filename();
+XBT_PRIVATE std::string TRACE_get_viva_uncat_conf();
+XBT_PRIVATE std::string TRACE_get_viva_cat_conf();
XBT_PRIVATE void TRACE_generate_viva_uncat_conf();
XBT_PRIVATE void TRACE_generate_viva_cat_conf();
XBT_PRIVATE void instr_pause_tracing();
XBT_LOG_NEW_DEFAULT_SUBCATEGORY(mc_ModelChecker, mc, "ModelChecker");
::simgrid::mc::ModelChecker* mc_model_checker = nullptr;
+extern std::string _sg_mc_dot_output_file;
using simgrid::mc::remote;
process_->init();
- if ((_sg_mc_dot_output_file != nullptr) && (_sg_mc_dot_output_file[0] != '\0'))
+ if (not _sg_mc_dot_output_file.empty())
MC_init_dot_output();
setup_ignore();
#include "src/smpi/include/private.hpp"
XBT_LOG_NEW_DEFAULT_SUBCATEGORY(mc_Session, mc, "Model-checker session");
+extern std::string _sg_mc_dot_output_file;
namespace simgrid {
namespace mc {
{
mc_model_checker->getChecker()->logState();
- if ((_sg_mc_dot_output_file != nullptr) && (_sg_mc_dot_output_file[0] != '\0')) {
+ if (not _sg_mc_dot_output_file.empty()) {
fprintf(dot_output, "}\n");
fclose(dot_output);
}
#include "src/mc/remote/Client.hpp"
XBT_LOG_NEW_DEFAULT_SUBCATEGORY(mc_liveness, mc, "Logging specific to algorithms for liveness properties verification");
+extern std::string _sg_mc_property_file;
/********* Static functions *********/
void LivenessChecker::run()
{
- XBT_INFO("Check the liveness property %s", _sg_mc_property_file);
- MC_automaton_load(_sg_mc_property_file);
+ XBT_INFO("Check the liveness property %s", _sg_mc_property_file.c_str());
+ MC_automaton_load(_sg_mc_property_file.c_str());
XBT_DEBUG("Starting the liveness algorithm");
simgrid::mc::session->initialize();
#include "src/mc/remote/mc_protocol.h"
XBT_LOG_NEW_DEFAULT_SUBCATEGORY(mc_main, mc, "Entry point for simgrid-mc");
+extern std::string _sg_mc_property_file;
static inline
char** argvdup(int argc, char** argv)
return argv_copy;
}
-static
-std::unique_ptr<simgrid::mc::Checker> createChecker(simgrid::mc::Session& session)
+static std::unique_ptr<simgrid::mc::Checker> createChecker(simgrid::mc::Session& session)
{
if (_sg_mc_comms_determinism || _sg_mc_send_determinism)
- return std::unique_ptr<simgrid::mc::Checker>(
- simgrid::mc::createCommunicationDeterminismChecker(session));
- else if (_sg_mc_property_file == nullptr || _sg_mc_property_file[0] == '\0')
- return std::unique_ptr<simgrid::mc::Checker>(
- simgrid::mc::createSafetyChecker(session));
+ return std::unique_ptr<simgrid::mc::Checker>(simgrid::mc::createCommunicationDeterminismChecker(session));
+ else if (_sg_mc_property_file.empty())
+ return std::unique_ptr<simgrid::mc::Checker>(simgrid::mc::createSafetyChecker(session));
else
- return std::unique_ptr<simgrid::mc::Checker>(
- simgrid::mc::createLivenessChecker(session));
+ return std::unique_ptr<simgrid::mc::Checker>(simgrid::mc::createLivenessChecker(session));
}
int main(int argc, char** argv)
int simcall_HANDLER_mc_random(smx_simcall_t simcall, int min, int max)
{
- if (not MC_is_active() && not MC_record_path)
+ if (not MC_is_active() && MC_record_path.empty())
return prng_random(min, max);
return simcall->mc_value;
}
#define PROT_RWX (PROT_READ | PROT_WRITE | PROT_EXEC)
#define PROT_RW (PROT_READ | PROT_WRITE)
#define PROT_RX (PROT_READ | PROT_EXEC)
+extern std::string _sg_mc_property_file;
+extern std::string _sg_mc_dot_output_file;
namespace simgrid {
namespace mc {
snapshot->to_ignore = mc_model_checker->process().ignored_heap();
- if (_sg_mc_max_visited_states > 0 || strcmp(_sg_mc_property_file, "")) {
+ if (_sg_mc_max_visited_states > 0 || not _sg_mc_property_file.empty()) {
snapshot->stacks = take_snapshot_stacks(snapshot.get());
if (_sg_mc_hash)
snapshot->hash = simgrid::mc::hash(*snapshot);
void _mc_cfg_cb_timeout(const char *name)
{
- if (_sg_cfg_init_status && not(_sg_do_model_check || MC_record_path))
+ if (_sg_cfg_init_status && not(_sg_do_model_check || not MC_record_path.empty()))
xbt_die("You are specifying a value to enable/disable timeout for wait requests after the initialization (through MSG_config?), but model-checking was not activated at config time (through bu the program was not runned under the model-checker (with simgrid-mc)). This won't work, sorry.");
_sg_mc_timeout = xbt_cfg_get_boolean(name);
int _sg_mc_checkpoint = 0;
int _sg_mc_sparse_checkpoint = 0;
int _sg_mc_ksm = 0;
-char *_sg_mc_property_file = nullptr;
+std::string _sg_mc_property_file;
int _sg_mc_hash = 0;
int _sg_mc_max_depth = 1000;
int _sg_mc_max_visited_states = 0;
-char *_sg_mc_dot_output_file = nullptr;
+std::string _sg_mc_dot_output_file;
int _sg_mc_comms_determinism = 0;
int _sg_mc_send_determinism = 0;
int _sg_mc_snapshot_fds = 0;
xbt_die
("You are specifying a reduction strategy after the initialization (through MSG_config?), but model-checking was not activated at config time (through bu the program was not runned under the model-checker (with simgrid-mc)). This won't work, sorry.");
- char *val = xbt_cfg_get_string(name);
- if (not strcasecmp(val, "none"))
+ std::string val = xbt_cfg_get_string(name);
+ if (val == "none")
simgrid::mc::reduction_mode = simgrid::mc::ReductionMode::none;
- else if (not strcasecmp(val, "dpor"))
+ else if (val == "dpor")
simgrid::mc::reduction_mode = simgrid::mc::ReductionMode::dpor;
else
- xbt_die("configuration option %s can only take 'none' or 'dpor' as a value",
- name);
+ xbt_die("configuration option %s can only take 'none' or 'dpor' as a value", name);
}
void _mc_cfg_cb_checkpoint(const char *name)
XBT_LOG_NEW_DEFAULT_SUBCATEGORY(mc_global, mc, "Logging specific to MC (global)");
+extern std::string _sg_mc_dot_output_file;
+
namespace simgrid {
namespace mc {
void MC_init_dot_output()
{
- dot_output = fopen(_sg_mc_dot_output_file, "w");
+ dot_output = fopen(_sg_mc_dot_output_file.c_str(), "w");
if (dot_output == nullptr) {
perror("Error open dot output file");
" Logging specific to MC record/replay facility");
extern "C" {
-char* MC_record_path = nullptr;
+std::string MC_record_path;
}
namespace simgrid {
}
}
-void replay(const char* path_string)
+void replay(std::string path_string)
{
simgrid::mc::processes_time.resize(SIMIX_process_get_maxpid());
- simgrid::mc::RecordTrace trace = simgrid::mc::parseRecordTrace(path_string);
+ simgrid::mc::RecordTrace trace = simgrid::mc::parseRecordTrace(path_string.c_str());
simgrid::mc::replay(trace);
simgrid::mc::processes_time.clear();
}
XBT_PRIVATE void dumpRecordPath();
XBT_PRIVATE void replay(RecordTrace const& trace);
-XBT_PRIVATE void replay(const char* trace);
+XBT_PRIVATE void replay(std::string trace);
}
}
*
* This is using the format generated by traceToString().
*/
-XBT_PUBLIC_DATA(char*) MC_record_path;
+XBT_PUBLIC_DATA(std::string) MC_record_path;
/** Whether the replay mode is enabled */
static inline int MC_record_replay_is_active() {
- return MC_record_path != 0;
+ return not MC_record_path.empty();
}
SG_END_DECL()
return simgrid::simix::kernelImmediate([this] { return pimpl_->getProperties(); });
}
-const char* Storage::getProperty(const char* key)
+const char* Storage::getProperty(std::string key)
{
return this->pimpl_->getProperty(key);
}
-void Storage::setProperty(const char* key, const char* value)
+void Storage::setProperty(std::string key, std::string value)
{
simgrid::simix::kernelImmediate([this, key, value] { this->pimpl_->setProperty(key, value); });
}
{
xbt_assert(_sg_cfg_init_status < 2, "Cannot load a plugin after the initialization");
- char *val = xbt_cfg_get_string(name);
- if (val==nullptr || val[0] == '\0')
+ std::string val = xbt_cfg_get_string(name);
+ if (val.empty())
return;
- if (not strcmp(val, "help")) {
+ if (val == "help") {
model_help("plugin", surf_plugin_description);
sg_cfg_exit_early();
}
{
xbt_assert(_sg_cfg_init_status < 2, "Cannot change the model after the initialization");
- char *val = xbt_cfg_get_string(name);
- if (not strcmp(val, "help")) {
+ std::string val = xbt_cfg_get_string(name);
+ if (val == "help") {
model_help("host", surf_host_model_description);
sg_cfg_exit_early();
}
{
xbt_assert(_sg_cfg_init_status < 2, "Cannot change the model after the initialization");
- char *val = xbt_cfg_get_string(name);
- if (not strcmp(val, "help")) {
+ std::string val = xbt_cfg_get_string(name);
+ if (val == "help") {
model_help("CPU", surf_cpu_model_description);
sg_cfg_exit_early();
}
{
xbt_assert(_sg_cfg_init_status < 2, "Cannot change the model after the initialization");
- char *val = xbt_cfg_get_string(name);
- if (not strcmp(val, "help")) {
+ std::string val = xbt_cfg_get_string(name);
+ if (val == "help") {
model_help("optimization", surf_optimization_mode_description);
sg_cfg_exit_early();
}
{
xbt_assert(_sg_cfg_init_status < 2, "Cannot change the model after the initialization");
- char *val = xbt_cfg_get_string(name);
- if (not strcmp(val, "help")) {
+ std::string val = xbt_cfg_get_string(name);
+ if (val == "help") {
model_help("storage", surf_storage_model_description);
sg_cfg_exit_early();
}
{
xbt_assert(_sg_cfg_init_status < 2, "Cannot change the model after the initialization");
- char *val = xbt_cfg_get_string(name);
- if (not strcmp(val, "help")) {
+ std::string val = xbt_cfg_get_string(name);
+ if (val == "help") {
model_help("network", surf_network_model_description);
sg_cfg_exit_early();
}
static void _sg_cfg_cb_model_check_replay(const char *name) {
MC_record_path = xbt_cfg_get_string(name);
- if (MC_record_path[0] == '\0')
- MC_record_path = nullptr;
}
#if SIMGRID_HAVE_MC
static void _sg_cfg_cb_contexts_parallel_mode(const char *name)
{
- const char* mode_name = xbt_cfg_get_string(name);
- if (not strcmp(mode_name, "posix")) {
+ std::string mode_name = xbt_cfg_get_string(name);
+ if (mode_name == "posix") {
SIMIX_context_set_parallel_mode(XBT_PARMAP_POSIX);
- } else if (not strcmp(mode_name, "futex")) {
+ } else if (mode_name == "futex") {
SIMIX_context_set_parallel_mode(XBT_PARMAP_FUTEX);
- } else if (not strcmp(mode_name, "busy_wait")) {
+ } else if (mode_name == "busy_wait") {
SIMIX_context_set_parallel_mode(XBT_PARMAP_BUSY_WAIT);
- }
- else {
+ } else {
xbt_die("Command line setting of the parallel synchronization mode should "
"be one of \"posix\", \"futex\" or \"busy_wait\"");
}
/* Plugins configuration */
describe_model(description, descsize, surf_plugin_description, "plugin", "The plugins");
- xbt_cfg_register_string("plugin", nullptr, &_sg_cfg_cb__plugin, description);
+ xbt_cfg_register_string("plugin", "", &_sg_cfg_cb__plugin, description);
describe_model(description, descsize, surf_cpu_model_description, "model", "The model to use for the CPU");
xbt_cfg_register_string("cpu/model", "Cas01", &_sg_cfg_cb__cpu_model, description);
*/
void SIMIX_run()
{
- if (MC_record_path) {
+ if (not MC_record_path.empty()) {
simgrid::mc::replay(MC_record_path);
return;
}
XBT_LOG_NEW_DEFAULT_SUBCATEGORY(smpi_coll, smpi, "Logging specific to SMPI (coll)");
-#define COLL_SETTER(cat, ret, args, args2)\
-int (*Colls::cat ) args;\
-void Colls::set_##cat (const char * name){\
- int id = find_coll_description(mpi_coll_## cat ##_description,\
- name,#cat);\
- cat = reinterpret_cast<ret (*) args>\
- (mpi_coll_## cat ##_description[id].coll);\
- if (cat == nullptr)\
- xbt_die("Collective "#cat" set to nullptr!");\
-}
+#define COLL_SETTER(cat, ret, args, args2) \
+ int(*Colls::cat) args; \
+ void Colls::set_##cat(std::string name) \
+ { \
+ int id = find_coll_description(mpi_coll_##cat##_description, name, #cat); \
+ cat = reinterpret_cast<ret(*) args>(mpi_coll_##cat##_description[id].coll); \
+ if (cat == nullptr) \
+ xbt_die("Collective " #cat " set to nullptr!"); \
+ }
-#define SET_COLL(coll)\
- name = xbt_cfg_get_string("smpi/"#coll);\
- if (name==nullptr || name[0] == '\0')\
- name = selector_name;\
- set_##coll(name);
+#define SET_COLL(coll) \
+ name = xbt_cfg_get_string("smpi/" #coll); \
+ if (name.empty()) \
+ name = selector_name; \
+ set_##coll(name);
namespace simgrid{
namespace smpi{
XBT_WARN(" %s: %s\n", table[i].name, table[i].description);
}
-int Colls::find_coll_description(s_mpi_coll_description_t * table, const char *name, const char *desc)
+int Colls::find_coll_description(s_mpi_coll_description_t* table, std::string name, const char* desc)
{
- char *name_list = nullptr;
for (int i = 0; table[i].name; i++)
- if (not strcmp(name, table[i].name)) {
+ if (name == table[i].name) {
if (strcmp(table[i].name,"default"))
XBT_INFO("Switch to algorithm %s for collective %s",table[i].name,desc);
return i;
}
if (not table[0].name)
- xbt_die("No collective is valid for '%s'! This is a bug.",name);
- name_list = xbt_strdup(table[0].name);
- for (int i = 1; table[i].name; i++) {
- name_list = static_cast<char*>(xbt_realloc(name_list, strlen(name_list) + strlen(table[i].name) + 3));
- strncat(name_list, ", ",2);
- strncat(name_list, table[i].name, strlen(table[i].name));
- }
- xbt_die("Collective '%s' is invalid! Valid collectives are: %s.", name, name_list);
+ xbt_die("No collective is valid for '%s'! This is a bug.", name.c_str());
+ std::string name_list = std::string(table[0].name);
+ for (int i = 1; table[i].name; i++)
+ name_list = name_list + ", " + table[i].name;
+
+ xbt_die("Collective '%s' is invalid! Valid collectives are: %s.", name.c_str(), name_list.c_str());
return -1;
}
-
-
COLL_APPLY(COLL_SETTER,COLL_GATHER_SIG,"");
COLL_APPLY(COLL_SETTER,COLL_ALLGATHER_SIG,"");
COLL_APPLY(COLL_SETTER,COLL_ALLGATHERV_SIG,"");
void Colls::set_collectives(){
- const char* selector_name = static_cast<char*>(xbt_cfg_get_string("smpi/coll-selector"));
- if (selector_name==nullptr || selector_name[0] == '\0')
- selector_name = "default";
-
- const char* name;
-
- SET_COLL(gather);
- SET_COLL(allgather);
- SET_COLL(allgatherv);
- SET_COLL(allreduce);
- SET_COLL(alltoall);
- SET_COLL(alltoallv);
- SET_COLL(reduce);
- SET_COLL(reduce_scatter);
- SET_COLL(scatter);
- SET_COLL(bcast);
- SET_COLL(barrier);
+ std::string selector_name = xbt_cfg_get_string("smpi/coll-selector");
+ if (selector_name.empty())
+ selector_name = "default";
+
+ std::string name;
+
+ SET_COLL(gather);
+ SET_COLL(allgather);
+ SET_COLL(allgatherv);
+ SET_COLL(allreduce);
+ SET_COLL(alltoall);
+ SET_COLL(alltoallv);
+ SET_COLL(reduce);
+ SET_COLL(reduce_scatter);
+ SET_COLL(scatter);
+ SET_COLL(bcast);
+ SET_COLL(barrier);
}
#ifndef SMPI_PRIVATE_HPP
#define SMPI_PRIVATE_HPP
+#include "include/xbt/config.hpp"
#include "simgrid/msg.h" // msg_bar_t
#include "smpi/smpi.h"
#include "src/instr/instr_smpi.hpp"
/** \brief MPI collective description */
-#define COLL_DEFS(cat, ret, args, args2)\
- static void set_##cat(const char* name);\
- static s_mpi_coll_description_t mpi_coll_##cat##_description[];\
- static int (*cat ) args;
+#define COLL_DEFS(cat, ret, args, args2) \
+ static void set_##cat(std::string name); \
+ static s_mpi_coll_description_t mpi_coll_##cat##_description[]; \
+ static int(*cat) args;
#define COLL_SIG(cat, ret, args, args2)\
static int cat args;
class Colls{
public:
static XBT_PUBLIC(void) coll_help(const char *category, s_mpi_coll_description_t * table);
- static XBT_PUBLIC(int) find_coll_description(s_mpi_coll_description_t * table, const char *name, const char *desc);
+ static XBT_PUBLIC(int) find_coll_description(s_mpi_coll_description_t* table, std::string name, const char* desc);
static void set_collectives();
// for each collective type, create the set_* prototype, the description array and the function pointer
namespace smpi{
class Datatype : public F2C, public Keyval{
- private:
- char* name_;
- size_t size_;
- MPI_Aint lb_;
- MPI_Aint ub_;
- int flags_;
- int refcount_;
-
- public:
- static std::unordered_map<int, smpi_key_elem> keyvals_;
- static int keyval_id_;
-
- Datatype(int size,MPI_Aint lb, MPI_Aint ub, int flags);
- Datatype(char* name, int size,MPI_Aint lb, MPI_Aint ub, int flags);
- Datatype(Datatype *datatype, int* ret);
- virtual ~Datatype();
-
- char* name();
- size_t size();
- MPI_Aint lb();
- MPI_Aint ub();
- int flags();
- int refcount();
-
- void ref();
- static void unref(MPI_Datatype datatype);
- void commit();
- bool is_valid();
- void addflag(int flag);
- int extent(MPI_Aint * lb, MPI_Aint * extent);
- MPI_Aint get_extent();
- void get_name(char* name, int* length);
- void set_name(char* name);
- static int copy(void *sendbuf, int sendcount, MPI_Datatype sendtype,
- void *recvbuf, int recvcount, MPI_Datatype recvtype);
- virtual void serialize( void* noncontiguous, void *contiguous,
- int count);
- virtual void unserialize( void* contiguous, void *noncontiguous,
- int count, MPI_Op op);
- static int keyval_create(MPI_Type_copy_attr_function* copy_fn, MPI_Type_delete_attr_function* delete_fn, int* keyval, void* extra_state);
- static int keyval_free(int* keyval);
- int pack(void* inbuf, int incount, void* outbuf, int outcount, int* position, MPI_Comm comm);
- int unpack(void* inbuf, int insize, int* position, void* outbuf, int outcount, MPI_Comm comm);
-
-
- static int create_contiguous(int count, MPI_Datatype old_type, MPI_Aint lb, MPI_Datatype* new_type);
- static int create_vector(int count, int blocklen, int stride, MPI_Datatype old_type, MPI_Datatype* new_type);
- static int create_hvector(int count, int blocklen, MPI_Aint stride, MPI_Datatype old_type, MPI_Datatype* new_type);
- static int create_indexed(int count, int* blocklens, int* indices, MPI_Datatype old_type, MPI_Datatype* new_type);
- static int create_hindexed(int count, int* blocklens, MPI_Aint* indices, MPI_Datatype old_type, MPI_Datatype* new_type);
- static int create_struct(int count, int* blocklens, MPI_Aint* indices, MPI_Datatype* old_types, MPI_Datatype* new_type);
-
- static Datatype* f2c(int id);
+ char* name_;
+ size_t size_;
+ MPI_Aint lb_;
+ MPI_Aint ub_;
+ int flags_;
+ int refcount_;
+
+public:
+ static std::unordered_map<int, smpi_key_elem> keyvals_;
+ static int keyval_id_;
+
+ Datatype(int size, MPI_Aint lb, MPI_Aint ub, int flags);
+ Datatype(char* name, int size, MPI_Aint lb, MPI_Aint ub, int flags);
+ Datatype(Datatype* datatype, int* ret);
+ virtual ~Datatype();
+
+ char* name();
+ size_t size();
+ MPI_Aint lb();
+ MPI_Aint ub();
+ int flags();
+ int refcount();
+
+ void ref();
+ static void unref(MPI_Datatype datatype);
+ void commit();
+ bool is_valid();
+ void addflag(int flag);
+ int extent(MPI_Aint* lb, MPI_Aint* extent);
+ MPI_Aint get_extent();
+ void get_name(char* name, int* length);
+ void set_name(char* name);
+ static int copy(void* sendbuf, int sendcount, MPI_Datatype sendtype, void* recvbuf, int recvcount,
+ MPI_Datatype recvtype);
+ virtual void serialize(void* noncontiguous, void* contiguous, int count);
+ virtual void unserialize(void* contiguous, void* noncontiguous, int count, MPI_Op op);
+ static int keyval_create(MPI_Type_copy_attr_function* copy_fn, MPI_Type_delete_attr_function* delete_fn, int* keyval,
+ void* extra_state);
+ static int keyval_free(int* keyval);
+ int pack(void* inbuf, int incount, void* outbuf, int outcount, int* position, MPI_Comm comm);
+ int unpack(void* inbuf, int insize, int* position, void* outbuf, int outcount, MPI_Comm comm);
+
+ static int create_contiguous(int count, MPI_Datatype old_type, MPI_Aint lb, MPI_Datatype* new_type);
+ static int create_vector(int count, int blocklen, int stride, MPI_Datatype old_type, MPI_Datatype* new_type);
+ static int create_hvector(int count, int blocklen, MPI_Aint stride, MPI_Datatype old_type, MPI_Datatype* new_type);
+ static int create_indexed(int count, int* blocklens, int* indices, MPI_Datatype old_type, MPI_Datatype* new_type);
+ static int create_hindexed(int count, int* blocklens, MPI_Aint* indices, MPI_Datatype old_type,
+ MPI_Datatype* new_type);
+ static int create_struct(int count, int* blocklens, MPI_Aint* indices, MPI_Datatype* old_types,
+ MPI_Datatype* new_type);
+
+ static Datatype* f2c(int id);
};
}
namespace smpi{
class Type_Contiguous: public Datatype {
- private:
- int block_count_;
- MPI_Datatype old_type_;
- public:
- Type_Contiguous(int size, MPI_Aint lb, MPI_Aint ub, int flags, int block_count, MPI_Datatype old_type);
- ~Type_Contiguous();
- void serialize( void* noncontiguous, void *contiguous,
- int count);
- void unserialize( void* contiguous_vector, void *noncontiguous_vector,
- int count, MPI_Op op);
+ int block_count_;
+ MPI_Datatype old_type_;
+
+public:
+ Type_Contiguous(int size, MPI_Aint lb, MPI_Aint ub, int flags, int block_count, MPI_Datatype old_type);
+ ~Type_Contiguous();
+ void serialize(void* noncontiguous, void* contiguous, int count);
+ void unserialize(void* contiguous_vector, void* noncontiguous_vector, int count, MPI_Op op);
};
class Type_Vector: public Datatype{
- private:
- int block_count_;
- int block_length_;
- int block_stride_;
- MPI_Datatype old_type_;
- public:
- Type_Vector(int size,MPI_Aint lb, MPI_Aint ub, int flags, int count, int blocklen, int stride, MPI_Datatype old_type);
- ~Type_Vector();
- void serialize( void* noncontiguous, void *contiguous,
- int count);
- void unserialize( void* contiguous_vector, void *noncontiguous_vector,
- int count, MPI_Op op);
+ int block_count_;
+ int block_length_;
+ int block_stride_;
+ MPI_Datatype old_type_;
+
+public:
+ Type_Vector(int size, MPI_Aint lb, MPI_Aint ub, int flags, int count, int blocklen, int stride,
+ MPI_Datatype old_type);
+ ~Type_Vector();
+ void serialize(void* noncontiguous, void* contiguous, int count);
+ void unserialize(void* contiguous_vector, void* noncontiguous_vector, int count, MPI_Op op);
};
class Type_Hvector: public Datatype{
- private:
- int block_count_;
- int block_length_;
- MPI_Aint block_stride_;
- MPI_Datatype old_type_;
- public:
- Type_Hvector(int size,MPI_Aint lb, MPI_Aint ub, int flags, int block_count, int block_length, MPI_Aint block_stride, MPI_Datatype old_type);
- ~Type_Hvector();
- void serialize( void* noncontiguous, void *contiguous,
- int count);
- void unserialize( void* contiguous_vector, void *noncontiguous_vector,
- int count, MPI_Op op);
+ int block_count_;
+ int block_length_;
+ MPI_Aint block_stride_;
+ MPI_Datatype old_type_;
+
+public:
+ Type_Hvector(int size, MPI_Aint lb, MPI_Aint ub, int flags, int block_count, int block_length, MPI_Aint block_stride,
+ MPI_Datatype old_type);
+ ~Type_Hvector();
+ void serialize(void* noncontiguous, void* contiguous, int count);
+ void unserialize(void* contiguous_vector, void* noncontiguous_vector, int count, MPI_Op op);
};
class Type_Indexed: public Datatype{
- private:
- int block_count_;
- int* block_lengths_;
- int* block_indices_;
- MPI_Datatype old_type_;
- public:
- Type_Indexed(int size,MPI_Aint lb, MPI_Aint ub, int flags, int block_count, int* block_lengths, int* block_indices, MPI_Datatype old_type);
- ~Type_Indexed();
- void serialize( void* noncontiguous, void *contiguous,
- int count);
- void unserialize( void* contiguous_vector, void *noncontiguous_vector,
- int count, MPI_Op op);
+ int block_count_;
+ int* block_lengths_;
+ int* block_indices_;
+ MPI_Datatype old_type_;
+
+public:
+ Type_Indexed(int size, MPI_Aint lb, MPI_Aint ub, int flags, int block_count, int* block_lengths, int* block_indices,
+ MPI_Datatype old_type);
+ ~Type_Indexed();
+ void serialize(void* noncontiguous, void* contiguous, int count);
+ void unserialize(void* contiguous_vector, void* noncontiguous_vector, int count, MPI_Op op);
};
class Type_Hindexed: public Datatype{
- private:
- int block_count_;
- int* block_lengths_;
- MPI_Aint* block_indices_;
- MPI_Datatype old_type_;
- public:
- Type_Hindexed(int size,MPI_Aint lb, MPI_Aint ub, int flags, int block_count, int* block_lengths, MPI_Aint* block_indices, MPI_Datatype old_type);
- ~Type_Hindexed();
- void serialize( void* noncontiguous, void *contiguous,
- int count);
- void unserialize( void* contiguous_vector, void *noncontiguous_vector,
- int count, MPI_Op op);
+ int block_count_;
+ int* block_lengths_;
+ MPI_Aint* block_indices_;
+ MPI_Datatype old_type_;
+
+public:
+ Type_Hindexed(int size, MPI_Aint lb, MPI_Aint ub, int flags, int block_count, int* block_lengths,
+ MPI_Aint* block_indices, MPI_Datatype old_type);
+ ~Type_Hindexed();
+ void serialize(void* noncontiguous, void* contiguous, int count);
+ void unserialize(void* contiguous_vector, void* noncontiguous_vector, int count, MPI_Op op);
};
class Type_Struct: public Datatype{
- private:
- int block_count_;
- int* block_lengths_;
- MPI_Aint* block_indices_;
- MPI_Datatype* old_types_;
- public:
- Type_Struct(int size,MPI_Aint lb, MPI_Aint ub, int flags, int block_count, int* block_lengths, MPI_Aint* block_indices, MPI_Datatype* old_types);
- ~Type_Struct();
- void serialize( void* noncontiguous, void *contiguous,
- int count);
- void unserialize( void* contiguous_vector, void *noncontiguous_vector,
- int count, MPI_Op op);
+ int block_count_;
+ int* block_lengths_;
+ MPI_Aint* block_indices_;
+ MPI_Datatype* old_types_;
+
+public:
+ Type_Struct(int size, MPI_Aint lb, MPI_Aint ub, int flags, int block_count, int* block_lengths,
+ MPI_Aint* block_indices, MPI_Datatype* old_types);
+ ~Type_Struct();
+ void serialize(void* noncontiguous, void* contiguous, int count);
+ void unserialize(void* contiguous_vector, void* noncontiguous_vector, int count, MPI_Op op);
};
return;
#if HAVE_PAPI
- if (xbt_cfg_get_string("smpi/papi-events")[0] != '\0') {
+ if (not xbt_cfg_get_string("smpi/papi-events").empty()) {
int event_set = smpi_process()->papi_event_set();
// PAPI_start sets everything to 0! See man(3) PAPI_start
if (PAPI_LOW_LEVEL_INITED == PAPI_is_initialized()) {
xbt_os_walltimer_start(global_timer);
}
- if (xbt_cfg_get_string("smpi/comp-adjustment-file")[0] != '\0') {
- std::string filename {xbt_cfg_get_string("smpi/comp-adjustment-file")};
+ std::string filename = xbt_cfg_get_string("smpi/comp-adjustment-file");
+ if (not filename.empty()) {
std::ifstream fstream(filename);
if (not fstream.is_open()) {
xbt_die("Could not open file %s. Does it exist?", filename.c_str());
// and the (computed) event_set.
std::map</* computation unit name */ std::string, papi_process_data> units2papi_setup;
- if (xbt_cfg_get_string("smpi/papi-events")[0] != '\0') {
+ if (not xbt_cfg_get_string("smpi/papi-events").empty()) {
if (PAPI_library_init(PAPI_VER_CURRENT) != PAPI_VER_CURRENT)
XBT_ERROR("Could not initialize PAPI library; is it correctly installed and linked?"
" Expected version is %i",
typedef boost::tokenizer<boost::char_separator<char>> Tokenizer;
boost::char_separator<char> separator_units(";");
- std::string str = std::string(xbt_cfg_get_string("smpi/papi-events"));
+ std::string str = xbt_cfg_get_string("smpi/papi-events");
Tokenizer tokens(str, separator_units);
// Iterate over all the computational units. This could be processes, hosts, threads, ranks... You name it.
}
static void smpi_init_options(){
- //return if already called
- if (smpi_cpu_threshold > -1)
- return;
- simgrid::smpi::Colls::set_collectives();
- simgrid::smpi::Colls::smpi_coll_cleanup_callback=nullptr;
- smpi_cpu_threshold = xbt_cfg_get_double("smpi/cpu-threshold");
- smpi_host_speed = xbt_cfg_get_double("smpi/host-speed");
- const char* smpi_privatize_option = xbt_cfg_get_string("smpi/privatization");
- if (std::strcmp(smpi_privatize_option, "no") == 0)
- smpi_privatize_global_variables = SMPI_PRIVATIZE_NONE;
- else if (std::strcmp(smpi_privatize_option, "yes") == 0)
- smpi_privatize_global_variables = SMPI_PRIVATIZE_DEFAULT;
- else if (std::strcmp(smpi_privatize_option, "mmap") == 0)
- smpi_privatize_global_variables = SMPI_PRIVATIZE_MMAP;
- else if (std::strcmp(smpi_privatize_option, "dlopen") == 0)
- smpi_privatize_global_variables = SMPI_PRIVATIZE_DLOPEN;
-
- // Some compatibility stuff:
- else if (std::strcmp(smpi_privatize_option, "1") == 0)
- smpi_privatize_global_variables = SMPI_PRIVATIZE_DEFAULT;
- else if (std::strcmp(smpi_privatize_option, "0") == 0)
- smpi_privatize_global_variables = SMPI_PRIVATIZE_NONE;
-
- else
- xbt_die("Invalid value for smpi/privatization: '%s'", smpi_privatize_option);
+ // return if already called
+ if (smpi_cpu_threshold > -1)
+ return;
+ simgrid::smpi::Colls::set_collectives();
+ simgrid::smpi::Colls::smpi_coll_cleanup_callback = nullptr;
+ smpi_cpu_threshold = xbt_cfg_get_double("smpi/cpu-threshold");
+ smpi_host_speed = xbt_cfg_get_double("smpi/host-speed");
+ std::string smpi_privatize_option = xbt_cfg_get_string("smpi/privatization");
+ if (smpi_privatize_option == "no" || smpi_privatize_option == "0")
+ smpi_privatize_global_variables = SMPI_PRIVATIZE_NONE;
+ else if (smpi_privatize_option == "yes" || smpi_privatize_option == "1")
+ smpi_privatize_global_variables = SMPI_PRIVATIZE_DEFAULT;
+ else if (smpi_privatize_option == "mmap")
+ smpi_privatize_global_variables = SMPI_PRIVATIZE_MMAP;
+ else if (smpi_privatize_option == "dlopen")
+ smpi_privatize_global_variables = SMPI_PRIVATIZE_DLOPEN;
+ else
+ xbt_die("Invalid value for smpi/privatization: '%s'", smpi_privatize_option.c_str());
#if defined(__FreeBSD__)
if (smpi_privatize_global_variables == SMPI_PRIVATIZE_MMAP) {
if (smpi_cpu_threshold < 0)
smpi_cpu_threshold = DBL_MAX;
- char* val = xbt_cfg_get_string("smpi/shared-malloc");
+ const char* val = xbt_cfg_get_string("smpi/shared-malloc").c_str();
if (not strcasecmp(val, "yes") || not strcmp(val, "1") || not strcasecmp(val, "on") ||
not strcasecmp(val, "global")) {
smpi_cfg_shared_malloc = shmalloc_global;
void* smpi_shared_malloc_partial(size_t size, size_t* shared_block_offsets, int nb_shared_blocks)
{
- char *huge_page_mount_point = xbt_cfg_get_string("smpi/shared-malloc-hugepage");
- bool use_huge_page = huge_page_mount_point[0] != '\0';
+ std::string huge_page_mount_point = xbt_cfg_get_string("smpi/shared-malloc-hugepage");
+ bool use_huge_page = not huge_page_mount_point.empty();
#ifndef MAP_HUGETLB /* If the system header don't define that mmap flag */
xbt_assert(not use_huge_page,
"Huge pages are not available on your system, you cannot use the smpi/shared-malloc-hugepage option.");
* We cannot use a same file for the two type of calls, since the first one needs to be
* opened in a hugetlbfs mount point whereas the second needs to be a "classical" file. */
if(use_huge_page && smpi_shared_malloc_bogusfile_huge_page == -1) {
- char* huge_page_filename = bprintf("%s/simgrid-shmalloc-XXXXXX", huge_page_mount_point);
- smpi_shared_malloc_bogusfile_huge_page = mkstemp(huge_page_filename);
- XBT_DEBUG("bogusfile_huge_page: %s\n", huge_page_filename);
- unlink(huge_page_filename);
- xbt_free(huge_page_filename);
+ std::string huge_page_filename = huge_page_mount_point + "/simgrid-shmalloc-XXXXXX";
+ smpi_shared_malloc_bogusfile_huge_page = mkstemp((char*)huge_page_filename.c_str());
+ XBT_DEBUG("bogusfile_huge_page: %s\n", huge_page_filename.c_str());
+ unlink(huge_page_filename.c_str());
}
if(smpi_shared_malloc_bogusfile == -1) {
char name[] = "/tmp/simgrid-shmalloc-XXXXXX";
XBT_LOG_NEW_DEFAULT_SUBCATEGORY(smpi_utils, smpi, "Logging specific to SMPI (utils)");
-std::vector<s_smpi_factor_t> parse_factor(const char *smpi_coef_string)
+std::vector<s_smpi_factor_t> parse_factor(std::string smpi_coef_string)
{
std::vector<s_smpi_factor_t> smpi_factor;
typedef boost::tokenizer<boost::char_separator<char>> Tokenizer;
boost::char_separator<char> sep(";");
boost::char_separator<char> factor_separator(":");
- std::string tmp_string(smpi_coef_string);
- Tokenizer tokens(tmp_string, sep);
+ Tokenizer tokens(smpi_coef_string, sep);
/**
* Iterate over patterns like A:B:C:D;E:F;G:H
Tokenizer factor_values(*token_iter, factor_separator);
s_smpi_factor_t fact;
if (factor_values.begin() == factor_values.end()) {
- xbt_die("Malformed radical for smpi factor: '%s'", smpi_coef_string);
+ xbt_die("Malformed radical for smpi factor: '%s'", smpi_coef_string.c_str());
}
unsigned int iteration = 0;
for (Tokenizer::iterator factor_iter = factor_values.begin(); factor_iter != factor_values.end(); ++factor_iter) {
flags_ |= DT_FLAG_COMMITED;
}
-
bool Datatype::is_valid(){
return (flags_ & DT_FLAG_COMMITED);
}
#include "smpi_op.hpp"
#include <xbt/log.h>
-XBT_LOG_EXTERNAL_CATEGORY(smpi_datatype);
-
namespace simgrid{
namespace smpi{
-
-Type_Contiguous::Type_Contiguous(int size, MPI_Aint lb, MPI_Aint ub, int flags, int block_count, MPI_Datatype old_type): Datatype(size, lb, ub, flags), block_count_(block_count), old_type_(old_type){
+Type_Contiguous::Type_Contiguous(int size, MPI_Aint lb, MPI_Aint ub, int flags, int block_count, MPI_Datatype old_type)
+ : Datatype(size, lb, ub, flags), block_count_(block_count), old_type_(old_type)
+{
old_type_->ref();
}
-Type_Contiguous::~Type_Contiguous(){
+Type_Contiguous::~Type_Contiguous()
+{
Datatype::unref(old_type_);
}
-
-void Type_Contiguous::serialize( void* noncontiguous_buf, void *contiguous_buf,
- int count){
+void Type_Contiguous::serialize(void* noncontiguous_buf, void* contiguous_buf, int count)
+{
char* contiguous_buf_char = static_cast<char*>(contiguous_buf);
char* noncontiguous_buf_char = static_cast<char*>(noncontiguous_buf)+lb();
memcpy(contiguous_buf_char, noncontiguous_buf_char, count * block_count_ * old_type_->size());
}
-void Type_Contiguous::unserialize( void* contiguous_buf, void *noncontiguous_buf,
- int count, MPI_Op op){
+
+void Type_Contiguous::unserialize(void* contiguous_buf, void* noncontiguous_buf, int count, MPI_Op op)
+{
char* contiguous_buf_char = static_cast<char*>(contiguous_buf);
char* noncontiguous_buf_char = static_cast<char*>(noncontiguous_buf)+lb();
int n= count*block_count_;
}
/** @brief Return the property associated to the provided key (or nullptr if not existing) */
-const char *PropertyHolder::getProperty(const char*key) {
+const char* PropertyHolder::getProperty(std::string key)
+{
if (properties_ == nullptr)
return nullptr;
auto prop = properties_->find(key);
PropertyHolder() = default;
~PropertyHolder();
- const char *getProperty(const char*id);
+ const char* getProperty(std::string key);
void setProperty(std::string id, std::string value);
/* FIXME: This should not be exposed, as users may do bad things with the dict they got (it's not a copy).
xbt_assert(not surf_cpu_model_pm);
xbt_assert(not surf_cpu_model_vm);
- char *optim = xbt_cfg_get_string("cpu/optim");
- if (not strcmp(optim, "TI")) {
+ if (xbt_cfg_get_string("cpu/optim") == "TI") {
surf_cpu_model_init_ti();
return;
}
CpuCas01Model::CpuCas01Model() : simgrid::surf::CpuModel()
{
- char *optim = xbt_cfg_get_string("cpu/optim");
+ std::string optim = xbt_cfg_get_string("cpu/optim");
bool select = xbt_cfg_get_boolean("cpu/maxmin-selective-update");
- if (not strcmp(optim, "Full")) {
+ if (optim == "Full") {
setUpdateMechanism(UM_FULL);
selectiveUpdate_ = select;
- } else if (not strcmp(optim, "Lazy")) {
+ } else if (optim == "Lazy") {
setUpdateMechanism(UM_LAZY);
selectiveUpdate_ = true;
xbt_assert(select || (xbt_cfg_is_default_value("cpu/maxmin-selective-update")),
"Disabling selective update while using the lazy update mechanism is dumb!");
} else {
- xbt_die("Unsupported optimization (%s) for this model", optim);
+ xbt_die("Unsupported optimization (%s) for this model", optim.c_str());
}
p_cpuRunningActionSetThatDoesNotNeedBeingChecked = new ActionList();
NetworkCm02Model::NetworkCm02Model()
:NetworkModel()
{
- char *optim = xbt_cfg_get_string("network/optim");
+ std::string optim = xbt_cfg_get_string("network/optim");
bool select = xbt_cfg_get_boolean("network/maxmin-selective-update");
- if (not strcmp(optim, "Full")) {
+ if (optim == "Full") {
setUpdateMechanism(UM_FULL);
selectiveUpdate_ = select;
- } else if (not strcmp(optim, "Lazy")) {
+ } else if (optim == "Lazy") {
setUpdateMechanism(UM_LAZY);
selectiveUpdate_ = true;
xbt_assert(select || (xbt_cfg_is_default_value("network/maxmin-selective-update")),
"You cannot disable selective update when using the lazy update mechanism");
} else {
- xbt_die("Unsupported optimization (%s) for this model. Accepted: Full, Lazy.", optim);
+ xbt_die("Unsupported optimization (%s) for this model. Accepted: Full, Lazy.", optim.c_str());
}
maxminSystem_ = lmm_system_new(selectiveUpdate_);
NetworkIBModel::NetworkIBModel() : NetworkSmpiModel()
{
- const char* IB_factors_string = xbt_cfg_get_string("smpi/IB-penalty-factors");
+ std::string IB_factors_string = xbt_cfg_get_string("smpi/IB-penalty-factors");
std::vector<std::string> radical_elements;
boost::split(radical_elements, IB_factors_string, boost::is_any_of(";"));
/* Pick the right models for CPU, net and host, and call their model_init_preparse */
static void surf_config_models_setup()
{
- const char* host_model_name = xbt_cfg_get_string("host/model");
- const char* network_model_name = xbt_cfg_get_string("network/model");
- const char* cpu_model_name = xbt_cfg_get_string("cpu/model");
- const char* storage_model_name = xbt_cfg_get_string("storage/model");
+ std::string host_model_name = xbt_cfg_get_string("host/model");
+ std::string network_model_name = xbt_cfg_get_string("network/model");
+ std::string cpu_model_name = xbt_cfg_get_string("cpu/model");
+ std::string storage_model_name = xbt_cfg_get_string("storage/model");
/* The compound host model is needed when using non-default net/cpu models */
if ((not xbt_cfg_is_default_value("network/model") || not xbt_cfg_is_default_value("cpu/model")) &&
xbt_cfg_set_string("host/model", host_model_name);
}
- XBT_DEBUG("host model: %s", host_model_name);
- if (not strcmp(host_model_name, "compound")) {
- xbt_assert(cpu_model_name, "Set a cpu model to use with the 'compound' host model");
- xbt_assert(network_model_name, "Set a network model to use with the 'compound' host model");
+ XBT_DEBUG("host model: %s", host_model_name.c_str());
+ if (host_model_name == "compound") {
+ xbt_assert(not cpu_model_name.empty(), "Set a cpu model to use with the 'compound' host model");
+ xbt_assert(not network_model_name.empty(), "Set a network model to use with the 'compound' host model");
int cpu_id = find_model_description(surf_cpu_model_description, cpu_model_name);
surf_cpu_model_description[cpu_id].model_init_preparse();
printf(" %s: %s\n", table[i].name, table[i].description);
}
-int find_model_description(s_surf_model_description_t* table, const char* name)
+int find_model_description(s_surf_model_description_t* table, std::string name)
{
for (int i = 0; table[i].name; i++)
- if (not strcmp(name, table[i].name)) {
+ if (name == table[i].name)
return i;
- }
if (not table[0].name)
xbt_die("No model is valid! This is a bug.");
- char* name_list = xbt_strdup(table[0].name);
- for (int i = 1; table[i].name; i++) {
- name_list = (char *) xbt_realloc(name_list, strlen(name_list) + strlen(table[i].name) + 3);
- strncat(name_list, ", ", 2);
- strncat(name_list, table[i].name, strlen(table[i].name));
- }
- xbt_die("Model '%s' is invalid! Valid models are: %s.", name, name_list);
+ std::string name_list = std::string(table[0].name);
+ for (int i = 1; table[i].name; i++)
+ name_list = name_list + ", " + table[i].name;
+
+ xbt_die("Model '%s' is invalid! Valid models are: %s.", name.c_str(), name_list.c_str());
return -1;
}
#include <map>
#include <stdexcept>
#include <string>
+#include <string>
#include <type_traits>
#include <typeinfo>
#include <vector>
simgrid_config = xbt_cfg_new();
atexit(sg_config_finalize);
}
- simgrid_config->registerOption<std::string>(name, desc,
- default_value ? default_value : "", cb_set);
+ simgrid_config->registerOption<std::string>(name, desc, default_value ? default_value : "", cb_set);
}
void xbt_cfg_register_boolean(const char *name, const char*default_value,xbt_cfg_cb_t cb_set, const char *desc)
* @param value the value to be added
*
*/
-void xbt_cfg_set_string(const char *key, const char *value)
+void xbt_cfg_set_string(const char* key, std::string value)
{
try {
- (*simgrid_config)[key].setValue<std::string>(value ? value : "");
+ (*simgrid_config)[key].setValue<std::string>(value);
return;
}
- TRANSLATE_EXCEPTIONS("Could not set variable %s to string %s", key, value);
+ TRANSLATE_EXCEPTIONS("Could not set variable %s to string %s", key, value.c_str());
}
/** @brief Set or add a boolean value to \a name within \a cfg
*
* \warning the returned value is the actual content of the config set
*/
-char *xbt_cfg_get_string(const char *key)
+std::string xbt_cfg_get_string(const char* key)
{
try {
- return (char*) (*simgrid_config)[key].getValue<std::string>().c_str();
+ return (*simgrid_config)[key].getValue<std::string>();
}
TRANSLATE_EXCEPTIONS("Could not get variable %s", key);
}