static void action_init(const char *const *action)
{
int i;
XBT_DEBUG("Initialize the counters");
smpi_replay_globals_t globals = xbt_new(s_smpi_replay_globals_t, 1);
globals->irecvs = xbt_dynar_new(sizeof(MPI_Request),NULL);
if(action[2]) MPI_DEFAULT_TYPE= MPI_DOUBLE; // default MPE dataype
else MPI_DEFAULT_TYPE= MPI_BYTE; // default TAU datatype
smpi_process_set_user_data((void*) globals);
/* start a simulated timer */
smpi_process_simulated_start();
/*initialize the number of active processes */
active_processes = smpi_process_count();
if (!reqq) {
reqq=xbt_new0(xbt_dynar_t,active_processes);
for(i=0;i<active_processes;i++){
reqq[i]=xbt_dynar_new(sizeof(MPI_Request),NULL);
}
}
}
static void action_init(const char *const *action)
{
XBT_DEBUG("Initialize the counters");
CHECK_ACTION_PARAMS(action, 0, 1);
if(action[2]) MPI_DEFAULT_TYPE= MPI_DOUBLE; // default MPE dataype
else MPI_DEFAULT_TYPE= MPI_BYTE; // default TAU datatype
/* start a simulated timer */
smpi_process_simulated_start();
/*initialize the number of active processes */
active_processes = smpi_process_count();
if (!reqq) {
reqq = xbt_dict_new();
}
set_reqq_self(xbt_dynar_new(sizeof(MPI_Request),&xbt_free_ref));
/*
reqq=xbt_new0(xbt_dynar_t,active_processes);
for(i=0;i<active_processes;i++){
reqq[i]=xbt_dynar_new(sizeof(MPI_Request),&xbt_free_ref);
}
}
*/
}
static void action_init(const char *const *action)
{
XBT_DEBUG("Initialize the counters");
smpi_replay_globals_t globals = xbt_new(s_smpi_replay_globals_t, 1);
globals->isends = xbt_dynar_new(sizeof(MPI_Request),NULL);
globals->irecvs = xbt_dynar_new(sizeof(MPI_Request),NULL);
smpi_process_set_user_data((void*) globals);
/* start a simulated timer */
smpi_process_simulated_start();
/*initialize the number of active processes */
active_processes = smpi_process_count();
}
static void action_init(const char *const *action)
{
XBT_DEBUG("Initialize the counters");
CHECK_ACTION_PARAMS(action, 0, 1)
if(action[2])
MPI_DEFAULT_TYPE=MPI_DOUBLE; // default MPE dataype
else MPI_DEFAULT_TYPE= MPI_BYTE; // default TAU datatype
/* start a simulated timer */
smpi_process_simulated_start();
/*initialize the number of active processes */
active_processes = smpi_process_count();
set_reqq_self(new std::vector<MPI_Request>);
}
void smpi_global_destroy(void)
{
int count = smpi_process_count();
int i;
smpi_bench_destroy();
if (MPI_COMM_WORLD != MPI_COMM_UNINITIALIZED){
while (smpi_group_unuse(smpi_comm_group(MPI_COMM_WORLD)) > 0);
xbt_barrier_destroy(process_data[0]->finalization_barrier);
}else{
smpi_deployment_cleanup_instances();
}
for (i = 0; i < count; i++) {
if(process_data[i]->comm_self!=MPI_COMM_NULL){
smpi_comm_destroy(process_data[i]->comm_self);
}
if(process_data[i]->comm_intra!=MPI_COMM_NULL){
smpi_comm_destroy(process_data[i]->comm_intra);
}
xbt_os_timer_free(process_data[i]->timer);
xbt_mutex_destroy(process_data[i]->mailboxes_mutex);
xbt_free(process_data[i]);
}
xbt_free(process_data);
process_data = NULL;
if (MPI_COMM_WORLD != MPI_COMM_UNINITIALIZED){
smpi_comm_cleanup_smp(MPI_COMM_WORLD);
smpi_comm_cleanup_attributes(MPI_COMM_WORLD);
if(smpi_coll_cleanup_callback!=NULL)
smpi_coll_cleanup_callback();
xbt_free(MPI_COMM_WORLD);
}
MPI_COMM_WORLD = MPI_COMM_NULL;
if (!MC_is_active()) {
xbt_os_timer_free(global_timer);
}
xbt_free(index_to_process_data);
if(smpi_privatize_global_variables)
smpi_destroy_global_memory_segments();
smpi_free_static();
}
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;
}
