smx_rdv_t mailbox_small;
xbt_os_timer_t timer;
MPI_Comm comm_self;
+ MPI_Comm comm_intra;
MPI_Comm* comm_world;
void *data; /* user data */
int index;
char state;
int sampling; /* inside an SMPI_SAMPLE_ block? */
char* instance_id;
+ int replaying; /* is the process replaying a trace */
xbt_bar_t finalization_barrier;
} s_smpi_process_data_t;
static smpi_process_data_t *process_data = NULL;
int process_count = 0;
int* index_to_process_data = NULL;
-
-
+extern double smpi_total_benched_time;
+xbt_os_timer_t global_timer;
MPI_Comm MPI_COMM_WORLD = MPI_COMM_UNINITIALIZED;
int MPI_UNIVERSE_SIZE;
proc->context->cleanup_func=SIMIX_process_cleanup;
char* instance_id = (*argv)[1];
int rank = atoi((*argv)[2]);
- index = SIMIX_process_get_PID(proc) -1;
+ index = smpi_process_index_of_smx_process(proc);
if(!index_to_process_data){
index_to_process_data=(int*)xbt_malloc(SIMIX_process_count()*sizeof(int));
if(temp_bar != NULL) data->finalization_barrier = temp_bar;
data->index = index;
data->instance_id = instance_id;
+ data->replaying = 0;
xbt_free(simcall_process_get_data(proc));
simcall_process_set_data(proc, data);
if (*argc > 3) {
free((*argv)[1]);
- free((*argv)[2]);
- memmove(&(*argv)[1], &(*argv)[3], sizeof(char *) * (*argc - 3));
+ memmove(&(*argv)[0], &(*argv)[2], sizeof(char *) * (*argc - 2));
(*argv)[(*argc) - 1] = NULL;
(*argv)[(*argc) - 2] = NULL;
}
data->argv = argv;
// set the process attached to the mailbox
simcall_rdv_set_receiver(data->mailbox_small, proc);
+
XBT_DEBUG("<%d> New process in the game: %p", index, proc);
if(smpi_privatize_global_variables){
- switch_data_segment(index);
+ smpi_switch_data_segment(index);
}
}
{
int index = smpi_process_index();
if(smpi_privatize_global_variables){
- switch_data_segment(index);
+ smpi_switch_data_segment(index);
}
process_data[index_to_process_data[index]]->state = SMPI_FINALIZED;
XBT_DEBUG("<%d> Process left the game", index);
*/
void smpi_process_finalize(void)
{
+ // This leads to an explosion of the search graph
+ // which cannot be reduced:
+ if(MC_is_active())
+ return;
+
int index = smpi_process_index();
// wait for all pending asynchronous comms to finish
xbt_barrier_wait(process_data[index_to_process_data[index]]->finalization_barrier);
-
}
/**
void smpi_process_mark_as_initialized(void)
{
int index = smpi_process_index();
- if ((index != MPI_UNDEFINED) && (!process_data[index_to_process_data[index]]->state != SMPI_FINALIZED))
+ if ((index != MPI_UNDEFINED) && (process_data[index_to_process_data[index]]->state != SMPI_FINALIZED))
process_data[index_to_process_data[index]]->state = SMPI_INITIALIZED;
}
+void smpi_process_set_replaying(int value){
+ int index = smpi_process_index();
+ if ((index != MPI_UNDEFINED) && (process_data[index_to_process_data[index]]->state != SMPI_FINALIZED))
+ process_data[index_to_process_data[index]]->replaying = value;
+}
+
+int smpi_process_get_replaying(){
+ int index = smpi_process_index();
+ if (index != MPI_UNDEFINED)
+ return process_data[index_to_process_data[index]]->replaying;
+ else return _xbt_replay_is_active();
+}
+
int smpi_global_size(void)
{
return data->comm_self;
}
+MPI_Comm smpi_process_get_comm_intra(void)
+{
+ smpi_process_data_t data = smpi_process_data();
+ return data->comm_intra;
+}
+
+void smpi_process_set_comm_intra(MPI_Comm comm)
+{
+ smpi_process_data_t data = smpi_process_data();
+ data->comm_intra = comm;
+}
+
void smpi_process_set_sampling(int s)
{
smpi_process_data_t data = smpi_process_data();
return data->sampling;
}
+
void print_request(const char *message, MPI_Request request)
{
- XBT_DEBUG
+ XBT_VERB
("%s request %p [buf = %p, size = %zu, src = %d, dst = %d, tag = %d, flags = %x]",
message, request, request->buf, request->size, request->src,
request->dst, request->tag, request->flags);
}
-void smpi_comm_copy_buffer_callback(smx_action_t comm,
+void smpi_comm_copy_buffer_callback(smx_synchro_t comm,
void *buff, size_t buff_size)
{
XBT_DEBUG("Copy the data over");
- if(_xbt_replay_is_active()) return;
void* tmpbuff=buff;
if((smpi_privatize_global_variables)
&& ((char*)buff < start_data_exe + size_data_exe )
){
XBT_DEBUG("Privatization : We are copying from a zone inside global memory... Saving data to temp buffer !");
- switch_data_segment(((smpi_process_data_t)SIMIX_process_get_data(comm->comm.src_proc))->index);
+ smpi_switch_data_segment(((smpi_process_data_t)SIMIX_process_get_data(comm->comm.src_proc))->index);
tmpbuff = (void*)xbt_malloc(buff_size);
memcpy(tmpbuff, buff, buff_size);
}
&& ((char*)comm->comm.dst_buff < start_data_exe + size_data_exe )
){
XBT_DEBUG("Privatization : We are copying to a zone inside global memory - Switch data segment");
- switch_data_segment(((smpi_process_data_t)SIMIX_process_get_data(comm->comm.dst_proc))->index);
+ smpi_switch_data_segment(((smpi_process_data_t)SIMIX_process_get_data(comm->comm.dst_proc))->index);
}
}
+
+void smpi_comm_null_copy_buffer_callback(smx_synchro_t comm,
+ void *buff, size_t buff_size)
+{
+ return;
+}
+
static void smpi_check_options(){
//check correctness of MPI parameters
XBT_INFO("You did not set the power of the host running the simulation. "
"The timings will certainly not be accurate. "
"Use the option \"--cfg=smpi/running_power:<flops>\" to set its value."
- "Check http://simgrid.org/simgrid/latest/doc/options.html#options_smpi_bench for more information. ");
+ "Check http://simgrid.org/simgrid/latest/doc/options.html#options_smpi_bench for more information.");
}
}
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;
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;
smpi_group_unuse(smpi_comm_group(process_data[i]->comm_self));
smpi_comm_destroy(process_data[i]->comm_self);
}
+ if(process_data[i]->comm_intra!=MPI_COMM_NULL){
+ smpi_group_unuse(smpi_comm_group(process_data[i]->comm_intra));
+ smpi_comm_destroy(process_data[i]->comm_intra);
+ }
xbt_os_timer_free(process_data[i]->timer);
simcall_rdv_destroy(process_data[i]->mailbox);
simcall_rdv_destroy(process_data[i]->mailbox_small);
XBT_LOG_CONNECT(smpi_mpi_dt);
XBT_LOG_CONNECT(smpi_pmpi);
XBT_LOG_CONNECT(smpi_replay);
+ XBT_LOG_CONNECT(smpi_rma);
}
SIMIX_global_init(&argc, argv);
+ 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_init_options();
-
smpi_global_init();
smpi_check_options();
fflush(stdout);
fflush(stderr);
- if (MC_is_active())
+ if (MC_is_active()) {
MC_do_the_modelcheck_for_real();
- else
+ } else {
+
SIMIX_run();
- if (sg_cfg_get_boolean("smpi/display_timing"))
- XBT_INFO("Simulation time: %g seconds.", SIMIX_get_clock());
+ 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 "
+ "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();
