/** @brief shows an exception content and the associated stack if available */
void xbt_ex_display(xbt_ex_t * e)
{
char *thrower = NULL;
if (e->pid != xbt_getpid())
thrower = bprintf(" on process %d",e->pid);
fprintf(stderr,
"** SimGrid: UNCAUGHT EXCEPTION received on %s(%d): category: %s; value: %d\n"
"** %s\n"
"** Thrown by %s()%s\n",
xbt_binary_name, xbt_getpid(),
xbt_ex_catname(e->category), e->value, e->msg,
e->procname, thrower ? thrower : " in this process");
XBT_CRITICAL("%s", e->msg);
xbt_free(thrower);
if (xbt_initialized==0 || smx_cleaned) {
fprintf(stderr, "Ouch. SimGrid is not initialized yet, or already closing. No backtrace available.\n");
return; /* Not started yet or already closing. Trying to generate a backtrace would probably fail */
}
if (!e->bt_strings)
xbt_ex_setup_backtrace(e);
#ifdef HAVE_BACKTRACE
if (e->used && e->bt_strings) {
/* We have everything to build neat backtraces */
int i;
int cutpath = 0;
TRY { // We don't want to have an exception while checking how to deal with the one we already have, do we?
cutpath = sg_cfg_get_boolean("exception/cutpath");
} CATCH_ANONYMOUS { }
fprintf(stderr, "\n");
for (i = 0; i < e->used; i++) {
if (cutpath) {
char* p = e->bt_strings[i];
xbt_str_rtrim(p, ":0123456789");
char* filename = strrchr(p, '/')+1;
char* end_of_message = strrchr(p, ' ');
int length = strlen(p)-strlen(end_of_message);
char* dest = malloc(length);
memcpy(dest, &p[0], length);
dest[length] = 0;
fprintf(stderr, "%s %s\n", dest, filename);
free(dest);
}
else {
fprintf(stderr, "%s\n", e->bt_strings[i]);
}
}
} else
/** @brief shows an exception content and the associated stack if available */
void xbt_ex_display(xbt_ex_t * e)
{
char *thrower = NULL;
if (e->pid != xbt_getpid())
thrower = bprintf(" on process %d",e->pid);
fprintf(stderr,
"** SimGrid: UNCAUGHT EXCEPTION received on %s(%d): category: %s; value: %d\n"
"** %s\n"
"** Thrown by %s()%s\n",
xbt_binary_name, xbt_getpid(),
xbt_ex_catname(e->category), e->value, e->msg,
e->procname, thrower ? thrower : " in this process");
XBT_CRITICAL("%s", e->msg);
xbt_free(thrower);
if (!e->bt_strings)
xbt_ex_setup_backtrace(e);
#ifdef HAVE_BACKTRACE
if (e->used && e->bt_strings) {
/* We have everything to build neat backtraces */
int i;
fprintf(stderr, "\n");
for (i = 0; i < e->used; i++) {
if (sg_cfg_get_boolean("exception/cutpath")) {
char* p = e->bt_strings[i];
xbt_str_rtrim(p, ":0123456789");
char* filename = strrchr(p, '/')+1;
char* end_of_message = strrchr(p, ' ');
int length = strlen(p)-strlen(end_of_message);
char* dest = malloc(length);
memcpy(dest, &p[0], length);
dest[length] = 0;
fprintf(stderr, "%s %s\n", dest, filename);
free(dest);
}
else {
fprintf(stderr, "%s\n", e->bt_strings[i]);
}
}
} else
#endif
{
fprintf(stderr,
"\n"
"** In %s() at %s:%d\n"
"** (no backtrace available)\n",
e->func, e->file, e->line);
}
}
/**
* \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);
}
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 (sg_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.");
}
}
smpi_global_destroy();
TRACE_end();
return 0;
}
static void smpi_init_options(){
int gather_id = find_coll_description(mpi_coll_gather_description,
sg_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,
sg_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,
sg_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,
sg_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,
sg_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,
sg_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,
sg_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,
sg_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,
sg_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,
sg_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,
sg_cfg_get_string("smpi/barrier"),"barrier");
mpi_coll_barrier_fun = (int (*)(MPI_Comm comm))
mpi_coll_barrier_description[barrier_id].coll;
smpi_cpu_threshold = sg_cfg_get_double("smpi/cpu_threshold");
smpi_running_power = sg_cfg_get_double("smpi/running_power");
smpi_privatize_global_variables = sg_cfg_get_boolean("smpi/privatize_global_variables");
if (smpi_cpu_threshold < 0)
smpi_cpu_threshold = DBL_MAX;
}
