static void _sg_cfg_cb_model_check_record(const char *name, int pos)
{
#ifdef HAVE_MC
_sg_do_model_check_record = xbt_cfg_get_boolean(_sg_cfg_set, name);
#else
if (xbt_cfg_get_boolean(_sg_cfg_set, name)) {
xbt_die("You tried to activate the model-checking record from the command line, but it was not compiled in. Change your settings in cmake, recompile and try again");
}
#endif
}
void print_TICreateContainer(paje_event_t event)
{
//if we are in the mode with only one file
static FILE *temp = nullptr;
if (tracing_files == nullptr) {
tracing_files = xbt_dict_new_homogeneous(nullptr);
//generate unique run id with time
prefix = xbt_os_time();
}
if (!xbt_cfg_get_boolean("tracing/smpi/format/ti-one-file") || temp == nullptr) {
char *folder_name = bprintf("%s_files", TRACE_get_filename());
char *filename = bprintf("%s/%f_%s.txt", folder_name, prefix, ((createContainer_t) event->data)->container->name);
#ifdef WIN32
_mkdir(folder_name);
#else
mkdir(folder_name, S_IRWXU | S_IRWXG | S_IRWXO);
#endif
temp = fopen(filename, "w");
xbt_assert(temp, "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);
}
xbt_dict_set(tracing_files, ((createContainer_t) event->data)->container->name, (void *) temp, nullptr);
}
void _mc_cfg_cb_ksm(const char *name)
{
if (_sg_cfg_init_status && !_sg_do_model_check)
xbt_die("You are specifying a KSM value after the initialization (through MSG_config?), but model-checking was not activated at config time (through --cfg=model-check:1). This won't work, sorry.");
_sg_mc_ksm = xbt_cfg_get_boolean(name);
}
void new_pajePushStateWithExtra (double timestamp, container_t container, type_t type, val_t value, void* extra)
{
paje_event_t event = xbt_new0(s_paje_event_t, 1);
event->event_type = PAJE_PushState;
event->timestamp = timestamp;
event->print = active_writer.print_PushState;
event->free = &free_paje_event;
event->data = xbt_new0(s_pushState_t, 1);
(static_cast<pushState_t>(event->data))->type = type;
(static_cast<pushState_t>(event->data))->container = container;
(static_cast<pushState_t>(event->data))->value = value;
(static_cast<pushState_t>(event->data))->extra = extra;
#if HAVE_SMPI
if (xbt_cfg_get_boolean("smpi/trace-call-location")) {
smpi_trace_call_location_t* loc = smpi_trace_get_call_location();
(static_cast<pushState_t>(event->data))->filename = loc->filename;
(static_cast<pushState_t>(event->data))->linenumber = loc->linenumber;
}
#endif
XBT_DEBUG("%s: event_type=%d, timestamp=%f", __FUNCTION__, static_cast<int>(event->event_type), event->timestamp);
insert_into_buffer (event);
}
void _mc_cfg_cb_timeout(const char *name)
{
if (_sg_cfg_init_status && !(_sg_do_model_check || MC_record_path))
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);
}
CpuCas01Model::CpuCas01Model() : simgrid::surf::CpuModel()
{
char *optim = xbt_cfg_get_string("cpu/optim");
bool select = xbt_cfg_get_boolean("cpu/maxmin-selective-update");
if (!strcmp(optim, "Full")) {
updateMechanism_ = UM_FULL;
selectiveUpdate_ = select;
} else if (!strcmp(optim, "Lazy")) {
updateMechanism_ = 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);
}
p_cpuRunningActionSetThatDoesNotNeedBeingChecked = new ActionList();
maxminSystem_ = lmm_system_new(selectiveUpdate_);
if (getUpdateMechanism() == UM_LAZY) {
actionHeap_ = xbt_heap_new(8, nullptr);
xbt_heap_set_update_callback(actionHeap_, surf_action_lmm_update_index_heap);
modifiedSet_ = new ActionLmmList();
maxminSystem_->keep_track = modifiedSet_;
}
}
static void smpi_init_options(){
int gather_id = find_coll_description(mpi_coll_gather_description, xbt_cfg_get_string("smpi/gather"),"gather");
mpi_coll_gather_fun = (int (*)(void *, int, MPI_Datatype, void *, int, MPI_Datatype, int, MPI_Comm))
mpi_coll_gather_description[gather_id].coll;
int allgather_id = find_coll_description(mpi_coll_allgather_description,
xbt_cfg_get_string("smpi/allgather"),"allgather");
mpi_coll_allgather_fun = (int (*)(void *, int, MPI_Datatype, void *, int, MPI_Datatype, MPI_Comm))
mpi_coll_allgather_description[allgather_id].coll;
int allgatherv_id = find_coll_description(mpi_coll_allgatherv_description,
xbt_cfg_get_string("smpi/allgatherv"),"allgatherv");
mpi_coll_allgatherv_fun = (int (*)(void *, int, MPI_Datatype, void *, int *, int *, MPI_Datatype, MPI_Comm))
mpi_coll_allgatherv_description[allgatherv_id].coll;
int allreduce_id = find_coll_description(mpi_coll_allreduce_description,
xbt_cfg_get_string("smpi/allreduce"),"allreduce");
mpi_coll_allreduce_fun = (int (*)(void *sbuf, void *rbuf, int rcount, MPI_Datatype dtype, MPI_Op op, MPI_Comm comm))
mpi_coll_allreduce_description[allreduce_id].coll;
int alltoall_id = find_coll_description(mpi_coll_alltoall_description,
xbt_cfg_get_string("smpi/alltoall"),"alltoall");
mpi_coll_alltoall_fun = (int (*)(void *, int, MPI_Datatype, void *, int, MPI_Datatype, MPI_Comm))
mpi_coll_alltoall_description[alltoall_id].coll;
int alltoallv_id = find_coll_description(mpi_coll_alltoallv_description,
xbt_cfg_get_string("smpi/alltoallv"),"alltoallv");
mpi_coll_alltoallv_fun = (int (*)(void *, int *, int *, MPI_Datatype, void *, int *, int *, MPI_Datatype, MPI_Comm))
mpi_coll_alltoallv_description[alltoallv_id].coll;
int bcast_id = find_coll_description(mpi_coll_bcast_description, xbt_cfg_get_string("smpi/bcast"),"bcast");
mpi_coll_bcast_fun = (int (*)(void *buf, int count, MPI_Datatype datatype, int root, MPI_Comm com))
mpi_coll_bcast_description[bcast_id].coll;
int reduce_id = find_coll_description(mpi_coll_reduce_description, xbt_cfg_get_string("smpi/reduce"),"reduce");
mpi_coll_reduce_fun = (int (*)(void *buf, void *rbuf, int count, MPI_Datatype datatype, MPI_Op op, int root,
MPI_Comm comm)) mpi_coll_reduce_description[reduce_id].coll;
int reduce_scatter_id =
find_coll_description(mpi_coll_reduce_scatter_description,
xbt_cfg_get_string("smpi/reduce-scatter"),"reduce_scatter");
mpi_coll_reduce_scatter_fun = (int (*)(void *sbuf, void *rbuf, int *rcounts,MPI_Datatype dtype, MPI_Op op,
MPI_Comm comm)) mpi_coll_reduce_scatter_description[reduce_scatter_id].coll;
int scatter_id = find_coll_description(mpi_coll_scatter_description, xbt_cfg_get_string("smpi/scatter"),"scatter");
mpi_coll_scatter_fun = (int (*)(void *sendbuf, int sendcount, MPI_Datatype sendtype, void *recvbuf,
int recvcount, MPI_Datatype recvtype, int root, MPI_Comm comm))
mpi_coll_scatter_description[scatter_id].coll;
int barrier_id = find_coll_description(mpi_coll_barrier_description, xbt_cfg_get_string("smpi/barrier"),"barrier");
mpi_coll_barrier_fun = (int (*)(MPI_Comm comm)) mpi_coll_barrier_description[barrier_id].coll;
smpi_coll_cleanup_callback=NULL;
smpi_cpu_threshold = xbt_cfg_get_double("smpi/cpu-threshold");
smpi_running_power = xbt_cfg_get_double("smpi/running-power");
smpi_privatize_global_variables = xbt_cfg_get_boolean("smpi/privatize-global-variables");
if (smpi_cpu_threshold < 0)
smpi_cpu_threshold = DBL_MAX;
}
void _mc_cfg_cb_hash(const char *name)
{
if (_sg_cfg_init_status && !_sg_do_model_check)
xbt_die
("You are specifying a value to enable/disable the use of global hash to speedup state comparaison, 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_hash = xbt_cfg_get_boolean(name);
}
void print_TIDestroyContainer(paje_event_t event)
{
if (!xbt_cfg_get_boolean("tracing/smpi/format/ti-one-file")|| xbt_dict_length(tracing_files) == 1) {
FILE* f = (FILE*)xbt_dict_get_or_null(tracing_files, ((destroyContainer_t) event->data)->container->name);
fclose(f);
}
xbt_dict_remove(tracing_files, ((destroyContainer_t) event->data)->container->name);
}
void _mc_cfg_cb_termination(const char *name)
{
if (_sg_cfg_init_status && !_sg_do_model_check)
xbt_die
("You are specifying a value to enable/disable the detection of non progressive cycles 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_termination = xbt_cfg_get_boolean(name);
}
void _mc_cfg_cb_snapshot_fds(const char *name)
{
if (_sg_cfg_init_status && !_sg_do_model_check)
xbt_die
("You are specifying a value to enable/disable the use of FD snapshotting, 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_snapshot_fds = xbt_cfg_get_boolean(name);
}
Session::Session(pid_t pid, int socket)
{
std::unique_ptr<simgrid::mc::Process> process(new simgrid::mc::Process(pid, socket));
// TODO, automatic detection of the config from the process
process->privatized(
xbt_cfg_get_boolean("smpi/privatize-global-variables"));
modelChecker_ = std::unique_ptr<ModelChecker>(
new simgrid::mc::ModelChecker(std::move(process)));
xbt_assert(mc_model_checker == nullptr);
mc_model_checker = modelChecker_.get();
mc_model_checker->start();
}
static void _sg_cfg_cb__surf_network_coordinates(const char *name,
int pos)
{
int val = xbt_cfg_get_boolean(_sg_cfg_set, name);
if (val) {
if (!COORD_HOST_LEVEL) {
COORD_HOST_LEVEL = xbt_lib_add_level(host_lib,xbt_dynar_free_voidp);
COORD_ASR_LEVEL = xbt_lib_add_level(as_router_lib,xbt_dynar_free_voidp);
}
} else
if (COORD_HOST_LEVEL)
xbt_die("Setting of whether to use coordinate cannot be disabled once set.");
}
static void _sg_cfg_cb__surf_network_coordinates(const char *name)
{
static int already_set = 0;
int val = xbt_cfg_get_boolean(name);
if (val) {
if (!already_set) {
COORD_HOST_LEVEL = sg_host_extension_create(xbt_dynar_free_voidp);
COORD_ASR_LEVEL = xbt_lib_add_level(as_router_lib,xbt_dynar_free_voidp);
}
already_set = 1;
} else
if (already_set)
xbt_die("Setting of whether to use coordinate cannot be disabled once set.");
}
CpuCas01Model::CpuCas01Model() : CpuModel("cpu")
{
char *optim = xbt_cfg_get_string(_sg_cfg_set, "cpu/optim");
int select = xbt_cfg_get_boolean(_sg_cfg_set, "cpu/maxmin_selective_update");
if (!strcmp(optim, "Full")) {
p_updateMechanism = UM_FULL;
m_selectiveUpdate = select;
} else if (!strcmp(optim, "Lazy")) {
p_updateMechanism = UM_LAZY;
m_selectiveUpdate = 1;
xbt_assert((select == 1)
||
(xbt_cfg_is_default_value
(_sg_cfg_set, "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);
}
p_cpuRunningActionSetThatDoesNotNeedBeingChecked = new ActionList();
if (getUpdateMechanism() == UM_LAZY) {
shareResources = &CpuCas01Model::shareResourcesLazy;
updateActionsState = &CpuCas01Model::updateActionsStateLazy;
} else if (getUpdateMechanism() == UM_FULL) {
shareResources = &CpuCas01Model::shareResourcesFull;
updateActionsState = &CpuCas01Model::updateActionsStateFull;
} else
xbt_die("Invalid cpu update mechanism!");
if (!p_maxminSystem) {
p_maxminSystem = lmm_system_new(m_selectiveUpdate);
}
if (getUpdateMechanism() == UM_LAZY) {
p_actionHeap = xbt_heap_new(8, NULL);
xbt_heap_set_update_callback(p_actionHeap, surf_action_lmm_update_index_heap);
p_modifiedSet = new ActionLmmList();
p_maxminSystem->keep_track = p_modifiedSet;
}
}
/**
* \ingroup msg_simulation
* \brief Initialize MSG with less verifications
* You should use the MSG_init() function instead. Failing to do so may turn into PEBKAC some day. You've been warned.
*/
void MSG_init_nocheck(int *argc, char **argv) {
TRACE_global_init(argc, argv);
xbt_getpid = MSG_process_self_PID;
if (!msg_global) {
msg_global = xbt_new0(s_MSG_Global_t, 1);
xbt_cfg_register_boolean("msg/debug-multiple-use", "no", _sg_cfg_cb_msg_debug_multiple_use,
"Print backtraces of both processes when there is a conflict of multiple use of a task");
SIMIX_global_init(argc, argv);
msg_global->sent_msg = 0;
msg_global->task_copy_callback = nullptr;
msg_global->process_data_cleanup = nullptr;
SIMIX_function_register_process_create(MSG_process_create_from_SIMIX);
SIMIX_function_register_process_cleanup(MSG_process_cleanup_from_SIMIX);
simgrid::surf::on_postparse.connect(MSG_post_create_environment);
simgrid::s4u::Host::onCreation.connect([](simgrid::s4u::Host& host) {
MSG_host_create_(&host);
});
MSG_HOST_LEVEL = simgrid::s4u::Host::extension_create([](void *p) {
__MSG_host_priv_free((msg_host_priv_t) p);
});
}
if(MC_is_active()){
/* Ignore total amount of messages sent during the simulation for heap comparison */
MC_ignore_heap(&(msg_global->sent_msg), sizeof(msg_global->sent_msg));
}
XBT_DEBUG("ADD MSG LEVELS");
MSG_STORAGE_LEVEL = xbt_lib_add_level(storage_lib, (void_f_pvoid_t) __MSG_storage_destroy);
MSG_FILE_LEVEL = xbt_lib_add_level(file_lib, (void_f_pvoid_t) __MSG_file_destroy);
if(xbt_cfg_get_boolean("clean-atexit"))
atexit(MSG_exit);
}
static void TRACE_header_PajePushState (int size)
{
fprintf(tracing_file, "%%EventDef PajePushState %d\n", PAJE_PushState);
fprintf(tracing_file, "%% Time date\n");
fprintf(tracing_file, "%% Type string\n");
fprintf(tracing_file, "%% Container string\n");
fprintf(tracing_file, "%% Value string\n");
if (size) fprintf(tracing_file, "%% Size int\n");
#if HAVE_SMPI
if (xbt_cfg_get_boolean("smpi/trace-call-location")) {
/**
* paje currently (May 2016) uses "Filename" and "Linenumber" as
* reserved words. We cannot use them...
*/
fprintf(tracing_file, "%% Fname string\n");
fprintf(tracing_file, "%% Lnumber int\n");
}
#endif
fprintf(tracing_file, "%%EndEventDef\n");
}
void NetworkCm02Model::initialize()
{
char *optim = xbt_cfg_get_string(_sg_cfg_set, "network/optim");
int select =
xbt_cfg_get_boolean(_sg_cfg_set, "network/maxmin_selective_update");
if (!strcmp(optim, "Full")) {
p_updateMechanism = UM_FULL;
m_selectiveUpdate = select;
} else if (!strcmp(optim, "Lazy")) {
p_updateMechanism = UM_LAZY;
m_selectiveUpdate = 1;
xbt_assert((select == 1)
||
(xbt_cfg_is_default_value
(_sg_cfg_set, "network/maxmin_selective_update")),
"Disabling selective update while using the lazy update mechanism is dumb!");
} else {
xbt_die("Unsupported optimization (%s) for this model", optim);
}
if (!p_maxminSystem)
p_maxminSystem = lmm_system_new(m_selectiveUpdate);
const char* lb_name = "__loopback__";
routing_model_create(createNetworkLink(lb_name,
498000000, NULL, 0.000015, NULL,
SURF_RESOURCE_ON, NULL,
SURF_LINK_FATPIPE, NULL));
if (p_updateMechanism == UM_LAZY) {
p_actionHeap = xbt_heap_new(8, NULL);
xbt_heap_set_update_callback(p_actionHeap, surf_action_lmm_update_index_heap);
p_modifiedSet = new ActionLmmList();
p_maxminSystem->keep_track = p_modifiedSet;
}
m_haveGap = false;
}
void new_pajeSetState (double timestamp, container_t container, type_t type, val_t value)
{
paje_event_t event = xbt_new0(s_paje_event_t, 1);
event->event_type = PAJE_SetState;
event->timestamp = timestamp;
event->print = active_writer.print_SetState;
event->free = free_paje_event;
event->data = xbt_new0(s_setState_t, 1);
((setState_t)(event->data))->type = type;
((setState_t)(event->data))->container = container;
((setState_t)(event->data))->value = value;
#if HAVE_SMPI
if (xbt_cfg_get_boolean("smpi/trace-call-location")) {
smpi_trace_call_location_t* loc = smpi_trace_get_call_location();
((setState_t)(event->data))->filename = loc->filename;
((setState_t)(event->data))->linenumber = loc->linenumber;
}
#endif
XBT_DEBUG("%s: event_type=%d, timestamp=%f", __FUNCTION__, (int)event->event_type, event->timestamp);
insert_into_buffer (event);
}
static void TRACE_getopts(void)
{
trace_enabled = xbt_cfg_get_boolean(OPT_TRACING);
trace_platform = xbt_cfg_get_boolean(OPT_TRACING_PLATFORM);
trace_platform_topology = xbt_cfg_get_boolean(OPT_TRACING_TOPOLOGY);
trace_smpi_enabled = xbt_cfg_get_boolean(OPT_TRACING_SMPI);
trace_smpi_grouped = xbt_cfg_get_boolean(OPT_TRACING_SMPI_GROUP);
trace_smpi_computing = xbt_cfg_get_boolean(OPT_TRACING_SMPI_COMPUTING);
trace_smpi_sleeping = xbt_cfg_get_boolean(OPT_TRACING_SMPI_SLEEPING);
trace_view_internals = xbt_cfg_get_boolean(OPT_TRACING_SMPI_INTERNALS);
trace_categorized = xbt_cfg_get_boolean(OPT_TRACING_CATEGORIZED);
trace_uncategorized = xbt_cfg_get_boolean(OPT_TRACING_UNCATEGORIZED);
trace_msg_process_enabled = xbt_cfg_get_boolean(OPT_TRACING_MSG_PROCESS);
trace_msg_vm_enabled = xbt_cfg_get_boolean(OPT_TRACING_MSG_VM);
trace_buffer = xbt_cfg_get_boolean(OPT_TRACING_BUFFER);
trace_onelink_only = xbt_cfg_get_boolean(OPT_TRACING_ONELINK_ONLY);
trace_disable_destroy = xbt_cfg_get_boolean(OPT_TRACING_DISABLE_DESTROY);
trace_basic = xbt_cfg_get_boolean(OPT_TRACING_BASIC);
trace_display_sizes = xbt_cfg_get_boolean(OPT_TRACING_DISPLAY_SIZES);
trace_disable_link = xbt_cfg_get_boolean(OPT_TRACING_DISABLE_LINK);
trace_disable_power = xbt_cfg_get_boolean(OPT_TRACING_DISABLE_POWER);
trace_precision = xbt_cfg_get_int(OPT_TRACING_PRECISION);
}
static void _sg_cfg_cb_verbose_exit(const char *name)
{
_sg_do_verbose_exit = xbt_cfg_get_boolean(name);
}
static void _sg_cfg_cb_model_check_record(const char *name, int pos) {
_sg_do_model_check_record = xbt_cfg_get_boolean(_sg_cfg_set, name);
}
static void _sg_cfg_cb__surf_network_crosstraffic(const char *name,
int pos)
{
sg_network_crosstraffic = xbt_cfg_get_boolean(_sg_cfg_set, name);
}
static void _sg_cfg_cb_verbose_exit(const char *name, int pos)
{
_sg_do_verbose_exit = xbt_cfg_get_boolean(_sg_cfg_set, name);
}
static void _sg_cfg_cb_clean_atexit(const char *name, int pos)
{
_sg_do_clean_atexit = xbt_cfg_get_boolean(_sg_cfg_set, name);
}
static void _sg_cfg_cb_msg_debug_multiple_use(const char *name)
{
msg_global->debug_multiple_use = xbt_cfg_get_boolean(name);
}
int sg_cfg_get_boolean(const char* name)
{
return xbt_cfg_get_boolean(_sg_cfg_set, name);
}
int smpi_main(int (*realmain) (int argc, char *argv[]), int argc, char *argv[])
{
srand(SMPI_RAND_SEED);
if (getenv("SMPI_PRETEND_CC") != NULL) {
/* Hack to ensure that smpicc can pretend to be a simple compiler. Particularly handy to pass it to the
* configuration tools */
return 0;
}
smpi_init_logs();
TRACE_global_init(&argc, argv);
TRACE_add_start_function(TRACE_smpi_alloc);
TRACE_add_end_function(TRACE_smpi_release);
SIMIX_global_init(&argc, argv);
MSG_init(&argc,argv);
SMPI_switch_data_segment = smpi_switch_data_segment;
smpi_init_options();
// parse the platform file: get the host list
SIMIX_create_environment(argv[1]);
SIMIX_comm_set_copy_data_callback(&smpi_comm_copy_buffer_callback);
SIMIX_function_register_default(realmain);
SIMIX_launch_application(argv[2]);
smpi_global_init();
smpi_check_options();
if(smpi_privatize_global_variables)
smpi_initialize_global_memory_segments();
/* Clean IO before the run */
fflush(stdout);
fflush(stderr);
if (MC_is_active()) {
MC_run();
} else {
SIMIX_run();
xbt_os_walltimer_stop(global_timer);
if (xbt_cfg_get_boolean("smpi/display-timing")){
double global_time = xbt_os_timer_elapsed(global_timer);
XBT_INFO("Simulated time: %g seconds. \n\n"
"The simulation took %g seconds (after parsing and platform setup)\n"
"%g seconds were actual computation of the application",
SIMIX_get_clock(), global_time , smpi_total_benched_time);
if (smpi_total_benched_time/global_time>=0.75)
XBT_INFO("More than 75%% of the time was spent inside the application code.\n"
"You may want to use sampling functions or trace replay to reduce this.");
}
}
int count = smpi_process_count();
int i, ret=0;
for (i = 0; i < count; i++) {
if(process_data[i]->return_value!=0){
ret=process_data[i]->return_value;//return first non 0 value
break;
}
}
smpi_global_destroy();
TRACE_end();
return ret;
}
static void _sg_cfg_cb_model_check_record(const char *name) {
_sg_do_model_check_record = xbt_cfg_get_boolean(name);
}
static void _sg_cfg_cb_clean_atexit(const char *name)
{
_sg_do_clean_atexit = xbt_cfg_get_boolean(name);
}