void MC_run()
{
simgrid::mc::processes_time.resize(simix_process_maxpid);
MC_ignore_heap(simgrid::mc::processes_time.data(),
simgrid::mc::processes_time.size() * sizeof(simgrid::mc::processes_time[0]));
smx_process_t process;
xbt_swag_foreach(process, simix_global->process_list)
MC_ignore_heap(&(process->process_hookup), sizeof(process->process_hookup));
simgrid::mc::Client::get()->mainLoop();
simgrid::mc::processes_time.clear();
}
void ContextFactory::declare_context(void* context, std::size_t size)
{
#if HAVE_MC
/* Store the address of the stack in heap to compare it apart of heap comparison */
if(MC_is_active())
MC_ignore_heap(context, size);
#endif
}
void Context::declare_context(std::size_t size)
{
#if SIMGRID_HAVE_MC
/* Store the address of the stack in heap to compare it apart of heap comparison */
if(MC_is_active())
MC_ignore_heap(this, size);
#endif
}
/* MSG_task_create related function*/
void TRACE_msg_task_create(msg_task_t task)
{
static long long counter = 0;
task->counter = counter++;
task->category = NULL;
if(MC_is_active())
MC_ignore_heap(&(task->counter), sizeof(task->counter));
XBT_DEBUG("CREATE %p, %lld", task, task->counter);
}
void smpi_global_init(void)
{
int i;
MPI_Group group;
char name[MAILBOX_NAME_MAXLEN];
int smpirun=0;
if (!MC_is_active()) {
global_timer = xbt_os_timer_new();
xbt_os_walltimer_start(global_timer);
}
if (process_count == 0){
process_count = SIMIX_process_count();
smpirun=1;
}
smpi_universe_size = process_count;
process_data = xbt_new0(smpi_process_data_t, process_count);
for (i = 0; i < process_count; i++) {
process_data[i] = xbt_new(s_smpi_process_data_t, 1);
//process_data[i]->index = i;
process_data[i]->argc = NULL;
process_data[i]->argv = NULL;
process_data[i]->mailbox = simcall_rdv_create(get_mailbox_name(name, i));
process_data[i]->mailbox_small =
simcall_rdv_create(get_mailbox_name_small(name, i));
process_data[i]->mailboxes_mutex = xbt_mutex_init();
process_data[i]->timer = xbt_os_timer_new();
if (MC_is_active())
MC_ignore_heap(process_data[i]->timer, xbt_os_timer_size());
process_data[i]->comm_self = MPI_COMM_NULL;
process_data[i]->comm_intra = MPI_COMM_NULL;
process_data[i]->comm_world = NULL;
process_data[i]->state = SMPI_UNINITIALIZED;
process_data[i]->sampling = 0;
process_data[i]->finalization_barrier = NULL;
}
//if the process was launched through smpirun script
//we generate a global mpi_comm_world
//if not, we let MPI_COMM_NULL, and the comm world
//will be private to each mpi instance
if(smpirun){
group = smpi_group_new(process_count);
MPI_COMM_WORLD = smpi_comm_new(group, NULL);
MPI_Attr_put(MPI_COMM_WORLD, MPI_UNIVERSE_SIZE, (void *)(MPI_Aint)process_count);
xbt_bar_t bar=xbt_barrier_init(process_count);
for (i = 0; i < process_count; i++) {
smpi_group_set_mapping(group, i, i);
process_data[i]->finalization_barrier = bar;
}
}
}
/**
* \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);
}
/**
* \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) {
#ifdef HAVE_TRACING
TRACE_global_init(argc, argv);
#endif
xbt_getpid = MSG_process_self_PID;
if (!msg_global) {
msg_global = xbt_new0(s_MSG_Global_t, 1);
xbt_cfg_register(&_sg_cfg_set, "msg/debug_multiple_use",
"Print backtraces of both processes when there is a conflict of multiple use of a task",
xbt_cfgelm_boolean, 1, 1, _sg_cfg_cb_msg_debug_multiple_use, NULL);
xbt_cfg_setdefault_boolean(_sg_cfg_set, "msg/debug_multiple_use", "no");
SIMIX_global_init(argc, argv);
#ifdef MSG_USE_DEPRECATED
msg_global->max_channel = 0;
#endif
msg_global->sent_msg = 0;
msg_global->task_copy_callback = NULL;
msg_global->process_data_cleanup = NULL;
SIMIX_function_register_process_create(MSG_process_create_from_SIMIX);
SIMIX_function_register_process_cleanup(MSG_process_cleanup_from_SIMIX);
sg_platf_postparse_add_cb(MSG_post_create_environment);
}
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_HOST_LEVEL = xbt_lib_add_level(host_lib, (void_f_pvoid_t) __MSG_host_priv_free);
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(sg_cfg_get_boolean("clean_atexit")) atexit(MSG_exit);
}